在以 4000 作为除数的 cuda gpu 上计算快速模运算。 eq: (ab)%4000

Question

i'm trying to optimize modulo arithmetic in cuda on pascal architecture (nvidia 1060) since the conventional (%) operator significantly slows down the code. I have seen some examples of optimization but they apply only if the divisor is a power of 2 or (2^k)-1. In my code, the divisor is 4000.

kindly, suggest me an optimized approach to calculate remainder in the below equation

  remainder = (a-b)%4000

Answer 1

I am assuming you can demonstrate how slow, say compared to modulo 4096 both with compiler optimisation and using bitmasks? If it is only 2 or 3 times slower you really can't beat it,

For fun, because I doubt you will beat the above metric:

Division is generally not that slow on modern processors, but one thing to be aware of is that when it was slow it depended on the size of the number being divided. Another is that unsigned divide was faster than signed divide.

One way to reduce the size of the number is to consider how a modulo is built up.

If you perform div and mod 4096, you can then ask, what is 4096 mod 4000 = 96. So the mod 4000 of your original number is (96 * div4096 + mod4096) mod 4000 where these are smaller numbers than you started with and might, just maybe, be faster because it uses fewer bits. Note that at this stage you can also use the relationship that 4000 = 32 * 125, so the bottom 5 bits will be the bottom 5 bits of the modulo, and you only need divide by 125.

Now on a 8-bit processor, dividing by less than 128 can be significantly faster than division by a bigger number! I doubt you have one of those, though.

Another option is to use high precision inverse multiply. Processors that have poor divide may have acceptable multiply. This trick is that you use the biggest integers that you can to perform a multiply that is 2^n/4000, where n is half the width of the large integer type, or can be higher, if the max number you need to divide is less than 2^n. The top part of that number (>>n) is the (approx) result of division, and if high enough resolution, should be "close enough". Multiply that value by 4000 again and subtract from your original, and you have your modulo +/- a few times 4000, for the cost of 2 big multiplies vs 1 smaller divide. On intel there is a multiply that inputs the 16 bit values ax*dx and outputs the 32 bit value dx:ax , and is replicated for 64-bit edx*eax => 128 bit edx:eax , but of course intel 386 and later has a fast-enough divide anyway.

And yet another generic approach, when the divisor you want is close to a power of 2, in your case 4000 is 97% of 4096:

loop:
  do the div4096 by bit shift
  multiply 4000 by div4096
  subtract
until result < 3*4096 
use if statement to get final mod value

This performs repeated multiplies, but each time, div4096 is a low estimator for div4000, by 3%, 0.03, about 1 in 64 or 6 bits, which gets cleaned up by the next iteration, so it will go round this loop perhaps 7 times for a 64-bit maxed out value. If mul is 7* faster than div, then you win. If the value you want to mod or div is more than a couple of percent off a power of 2, then the iteration count gets too high.