Why Does a Java Switch Statement on Contiguous Integers Perform Faster with More Cases?

What explains the surprising performance of the Java switch statement when it has a greater number of contiguous case statements?

double multiplyByPowerOfTen(final double d, final int exponent) {
   switch (exponent) {
      case 0:
         return d;
      case 1:
         return d * 10;
      case 2:
         return d * 100;
      // ... same pattern
      case 9:
         return d * 1000000000;
      case 10:
         return d * 10000000000L;
      // ... up to 18 and possibly more
      default:
         throw new ParseException("Unhandled power of ten " + exponent, 0);
   }
}

In Java, the switch statement exhibits performance characteristics that can be counterintuitive, particularly when comparing the execution time of a switch block with different numbers of cases. This phenomenon has been observed in scenarios where more contiguous case statements lead to quicker execution times, contrary to the expectation that adding more cases would slow down processing.

// Example of a more efficient array-based approach
public double multiplyByPowerOfTenArray(final double d, final int exponent) {
   long[] powersOfTen = {1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L,
                          10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L,
                          1000000000000000L, 10000000000000000L, 100000000000000000L, 1000000000000000000L};
   if (exponent < 0 || exponent >= powersOfTen.length) {
       throw new IllegalArgumentException("Exponent out of bounds");
   }
   return d * powersOfTen[exponent];
}

Causes

• Java's switch statement optimizes for contiguous integer cases using jump tables (or similar structures), which can lead to faster execution as the number of cases increases.
• When cases are generated in a contiguous manner, the JVM can leverage optimization techniques that reduce branching, resulting in fewer pipeline stalls and faster execution.
• The observed improvement in performance when multiple dummy cases are added suggests that the JVM may be better able to predict the binary flow of control, enhancing overall efficiency.

Solutions

• Use contiguous case statements when implementing switch structures for integer values, as it may yield better performance due to optimizations by the JVM.
• Conduct thorough benchmarking under identical conditions to determine optimal implementations for performance-intensive code, keeping in mind that performance can be architecture-specific.
• Consider refactoring your switch cases into array-based structures for certain use cases, as this can sometimes yield even greater performance gains.

Mistake: Over-relying on microbenchmarks that do not account for JVM warm-up time and other optimizations.

Solution: Ensure tests are run long enough to allow the JVM to optimize before collecting benchmark results.

Mistake: Assuming the switch statement's performance will linearly degrade with more cases.

Solution: Research and understand how the JVM implements switch statements and optimize accordingly.