Generate a lookup table to divide by a 10 bit integer through multiplication - template-meta-programming

Question

I have an integer that's a multiple of 256 between 256 and 131072
and I want to divide it by an integer between 1 and 1024
This is a hotspot in the inner loop of my code and commenting it speeds up my application dramatically.
Can I make a size 1024 lookup table that will help convert the division into a "multiplication plus shift" in less time than the actual division on an x86_64 cpu?
Can someone help come up with code to generate the lookup table that allows an efficient division by one of those 1024 possible divisors?
I would love to see a template metaprogramming way of generating the relevant table as a constexpr.

Answer 1

Because the choice of dividends and divisors is very restricted, one can use a simpler approach than is used in the paper by Torbjörn Granlund and Peter Montgomery that you located. I am not versed in C++ template meta programming, but I can demonstrate the approach of generating and using a table of appropriately scaled reciprocals.
First we note that the dividends are all multiples of 256, so they can be reduced to 1 ... 0x200 by a simple pre-shift to the right of 8 bits. Since we don't want to overflow an unsigned 32-bit integer during the multiplication of the reduced dividend with the scale reciprocal, the reciprocal is ideally scaled into the range 0x00200000 < rcp <= 0x00400000.
If a fast count-leading-zero instruction is available, it can be used to scale up the reciprocal into this range during table pre-computation, based on the logarithm base-2 of the divisor, then at run time use the same dynamically computed scale factor to scale down the product of the reduced dividend and scaled reciprocal by the same factor. When scaling up the reciprocal, we need to round up the result to next integer to compensate for the truncating nature of the down-scaling via right shift. Variant 0 in the code below uses this approach.
What should we do when no fast count-leading-zero instruction is available? We need to store the scaled reciprocal with a sufficient number of bits to maintain the accuracy of the computation. It turns out that we get lucky here due to the tight restriction on divisor range, and can make do with just two different scale factors that can be easily computed from the divisor at run time: one factor for divisors <= 32, the other for divisors in (32, 1024). This is used in variant 1 of the code, where the two scale factors worked out to 214 and 219.
Lastly, we may not want to compute the scale factor on the fly, but rather store it along with the scaled reciprocal, by using the most significant bits of each table entry to store them while the less significant bits are used for the reciprocal itself. One drawback is the need for additional operations to extract scaled reciprocal and scale factor from the table entry, which makes this approach less suitable than the other two. This is shown in code variant 2 below.
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#define VARIANT 0 // variants available: 0 ... 2
extern int __clz (uint32_t x); // intrinsic for access to CLZ instruction
uint32_t rcp [1025]; // table of scaled reciprocals (& possibly scale factors)
#define PRE_SCALE (8) // downscaling for dividends, since multiples of 256
#define POST_SCALE_1 (14) // upscale factor #1 for reciprocals
#define POST_SCALE_2 (19) // upscale factor #2 for reciprocals
#define RECIP_BITS (24) // bits used in table entry for scaled reciprocal
// helper function: logarithm base-2 of an 32-bit integer
int ilog2 (uint32_t x)
{
return 31 - __clz (x);
}
// division for dividends n*256, n in [1,512], divisor in [1,1024]
uint32_t fast_div (uint32_t dividend, uint32_t divisor)
{
#if VARIANT == 0
uint32_t scale = POST_SCALE_1 + ilog2 (divisor);
return ((dividend >> PRE_SCALE) * rcp[divisor]) >> scale;
#elif VARIANT == 1
uint32_t scale = (divisor > 0x20) ? POST_SCALE_2 : POST_SCALE_1;
return ((dividend >> PRE_SCALE) * rcp[divisor]) >> scale;
#elif VARIANT == 2
uint32_t scale = rcp[divisor] >> RECIP_BITS;
return ((dividend >> PRE_SCALE) * (rcp[divisor] & ((1 << RECIP_BITS) - 1))) >> scale;
#else
#error non-existing VARIANT
#endif
}
int main (void)
{
uint32_t dividend, divisor, res, ref;
int i;
// precompute table of recprocals
for (i = 1; i < 1025; i++) {
#if VARIANT == 0
uint32_t scale = POST_SCALE_1 + ilog2 (i);
rcp[i] = ((uint32_t)(pow (2.0, PRE_SCALE + scale) / i + 0.99999));
#elif VARIANT == 1
uint32_t scale = (i > 0x20) ? POST_SCALE_2 : POST_SCALE_1;
rcp[i] = ((uint32_t)(pow (2.0, PRE_SCALE + scale) / i + 0.99999));
#elif VARIANT == 2
uint32_t scale = (i > 0x20) ? POST_SCALE_2 : POST_SCALE_1;
rcp[i] = ((uint32_t)(pow (2.0, PRE_SCALE + scale) / i + 0.99999) +
(scale << RECIP_BITS));
#else
#error non-existing VARIANT
#endif
}
// test all supported dividens and divisors exhaustively
divisor = 1;
while (divisor <= 1024) {
dividend = 256;
while (dividend <= 131072) {
res = fast_div (dividend, divisor);
ref = dividend / divisor;
if (res != ref) {
printf ("n=%08x d=%08x res=%08x ref=%08x rcp=%08x\n",
dividend, divisor, res, ref, rcp[divisor]);
return EXIT_FAILURE;
}
dividend += 256;
}
divisor++;
}
printf ("division test passed\n");
return EXIT_SUCCESS;
}