通过16位移位进行32位乘法运算

Question

I am writing a soft-multiplication function call using shifting and addition. The existing function call goes like this:

unsigned long __mulsi3 (unsigned long a, unsigned long b) {

    unsigned long answer = 0;

    while(b)
    {
        if(b & 1) {
            answer += a;
        };

        a <<= 1;
        b >>= 1;
    }
    return answer;
}

Although my hardware does not have a multiplier, I have a hard shifter. The shifter is able to shift up to 16 bits at one time.

If I want to make full use of my 16-bit shifter. Any suggestions on how can I adapt the code above to reflect my hardware's capabilities? The given code shifts only 1-bit per iteration.

The 16-bit shifter can shift 32-bit unsigned long values up to 16 places at a time. The sizeof(unsigned long) == 32 bits

Answer 1

The ability to shift multiple bits is not going to help much, unless you have a hardware multiply, say 8-bit x 8-bit, or you can afford some RAM/ROM to do (say) a 4-bit by 4-bit multiply by lookup.

The straightforward shift and add (as you are doing) can be helped by swapping the arguments so that the multiplier is the smaller.

If your machine is faster doing 16 bit things in general, then treating your 32-bit 'a' as 'a1:a0' 16-bits at a time, and similarly 'b', you just might be able to same some cycles. Your result is only 32-bits, so you don't need to do 'a1 * b1' -- though one or both of those may be zero, so the win may not be big! Also, you only need the ls 16-bits of 'a0 * b1', so that can be done entirely 16-bits -- but if b1 (assuming b <= a) is generally zero this is not a big win, either. For 'a * b0', you need a 32-bit 'a' and 32-bit adds into 'answer', but your multiplier is 16-bits only... which may or may not help.

Skipping runs of multiplier zeros could help -- depending on processor and any properties of the multiplier.

FWIW: doing the magic 'a1*b1', '(a1-a0)*(b0-b1)', 'a0*b0' and combining the result by shifts, adds and subtracts is, in my small experience, an absolute nightmare... the signs of '(a1-a0)', '(b0-b1)' and their product have to be respected, which makes a bit of a mess of what looks like a cute trick. By the time you have finished with that and the adds and subtracts, you have to have a mighty slow multiply to make it all worth while ! When multiplying very, very long integers this may help... but there the memory issues may dominate... when I tried it, it was something of a disappointment.

Answer 2

Having 16-bit shifts can help you in making minor speed enhancement using the following approach:

(U1 * P + U0) * (V1 * P + V0) =
= U1 * V1 * P * P + U1 * V0 * P + U0 * V1 * P + U0 * V0 =
= U1 * V1 * (P*P+P) + (U1-U0) * (V0-V1) * P + U0 * V0 * (1-P)

provided P is a convenient power of 2 (for example, 2^16, 2^32), so multiplying to it is a fast shift. This reduces from 4 to 3 multiplications of smaller numbers, and, recursively, O(N^1.58) instead of O(N^2) for very long numbers.

This method is named Karatsubaʼs multiplication . There are more advanced versions described there.

For small numbers (eg 8 by 8 bits), the following method is fast, if you have enough fast ROM:

a * b = square(a+b)/4 - square(a-b)/4

if to tabulate int(square(x)/4) , you'll need 1022 bytes for unsigned multiplication and 510 bytes for signed one.

Answer 3

The basic approach is (assuming shifting by 1) :-

• Shift the top 16 bits
• Set the bottom bit of the top 16 bits to the top bit of the bottom 16 bits
• Shift the bottom 16 bits

Depends a bit on your hardware...

but you could try :-

• assuming unsigned long is 32 bits
• assuming Big Endian

then :-

 union Data32
        {
           unsigned long l;
           unsigned short s[2];
        }; 

unsigned long shiftleft32(unsigned long valueToShift, unsigned short bitsToShift)
{
    union Data32 u;
    u.l  = valueToShift
    u.s[0] <<= bitsToShift;
    u.s[0] |= (u.s[1] >> (16 - bitsToShift);
    u.s[1] <<= bitsToShift

    return u.l;
}

then do the same in reverse for shifting right

Answer 4

the code above is multiplying on the traditional way, the way we learnt in primary school :

EX:

    0101
  * 0111
  -------
    0101
   0101.
  0101..
 --------
  100011

of course you can not approach it like that if you don't have either a multiplier operator or 1-bit shifter! though, you can do it in other ways, for example a loop :

unsigned long _mult(unsigned long a, unsigned long b)
{
    unsigned long res =0;

    while (a > 0)
    {
        res += b;
        a--;
    }

    return res;
} 

It is costy but it serves your needings, anyways you can think about other approaches if you have more constraints (like computation time ...)