Why Is Recursion Depth Non-Deterministic in Java 8 but Deterministic in OpenJDK 7?

Non-Deterministic Stack Depth in Java 8

Determining the maximum recursion depth in Java can be crucial for understanding stack utilization and potential memory issues. However, on Oracle's Java 8, the reported results can be non-deterministic, while in contrast, OpenJDK 7 yields consistent outcomes.

Influence of the HotSpot Optimizer

The HotSpot compiler optimizer significantly affects the observed behavior. When recursive methods are JIT-compiled, the optimizer may optimize out certain method calls or merge the stack frames of multiple invocations. This optimization leads to a smaller stack space requirement, which allows for a deeper recursion.

Example

Consider the following code:

<code class="java">public static int countDepth() {
    try { return 1+countDepth(); }
    catch(StackOverflowError err) { return 0; }
}</code>

Results with JIT (from Oracle's Java 8):

2097
4195
4195
4195
12587
12587
12587

Results without JIT (from Oracle's Java 8):

2104
2104
2104
2104
2104
2104
2104

Stack Limit Enforcement and ASLR

Another factor influencing the non-determinism is the way the JVM enforces its stack limit. If the stack end address requires special alignment (e.g., aligning to page boundaries due to hardware restrictions), the initial stack allocation may have a weaker alignment constraint. Combined with Address Space Layout Randomization (ASLR), this could result in variable amounts of available stack space, leading to non-deterministic recursion depths.

Determinism in OpenJDK 7

In contrast to Oracle's Java 8, OpenJDK 7 seems to have a more consistent enforcement of stack limits and does not apply ASLR by default. This explains the deterministic behavior observed in OpenJDK 7.

The above is the detailed content of Why Is Recursion Depth Non-Deterministic in Java 8 but Deterministic in OpenJDK 7?. For more information, please follow other related articles on the PHP Chinese website!