While optimizing a number-crunching algorithm, I noticed (almost by accident) that a large amount of time was spent performing modulo/remainder operations (%) used for wrapping around the ends of arrays.  I found that changing

i = (i + 1) % n;

to

i++;
while(i >= n) {
  i -= n;
}

sped up my code.  I decided to investigate how fast the common integer arithmetic operators are.  I ran some tests using a microbenchmarking tool I wrote.  (It takes care of warming up the code for JIT compiling, randomizing test order, and repeating tests to calculate variability.)  For comparison, I wrote a similar tool in C++ and tested the operations with it, too.  I included three ways of incrementing with wraparound:

• i = (i + 1) % n;
• i++; while(i > n) i -= n;
• i++; if(i > n) i -= n;

Here are the results.  Times are the time to perform a single operation:

Why are there differences between the Java and C++ results?  I’m not sure, but they are reproducible and consistent.  Almost certainly, it boils down to the exact native opcodes the code is (just-in-time) compiled to.

Also surprising is that incrementing with a “while” check is faster than incrementing with an “if” check.  I expected the “while” to be slower, because it requires an additional comparison after i is decremented.  Whatever the cause is, it is reproducible and fairly consistent across Java and C++.

Of course, results will vary by compiler, JVM, and architecture, so this should all be taken with a grain of salt.