RFR: 8273392: Improve usability of stack-less exceptions due to -XX:+OmitStackTraceInFastThrow [v3]

[Xin Liu]

On Tue, 21 Sep 2021 10:09:11 GMT, Volker Simonis <simonis at openjdk.org> wrote:

>> If running with `-XX:+OmitStackTraceInFastThrow` (which is the default) C2 will optimize certain "hot" implicit exceptions (i.e. AIOOBE, NullPointerExceptions,..) and replace them by a static, pre-allocated exception without any stacktrace.
>> 
>> However, we can actually do better. Instead of using a single, pre-allocated exception object for all methods we can let the compiler allocate specific exceptions for each compilation unit (i.e. nmethod) and fill them with at least one stack frame with the method /line-number information of the currently compiled method. If the method in question is being inlined (which often happens), we can add stackframes for all callers up to the inlining depth of the method in question.
>> 
>> For the attached JTreg test, we get the following exception in interpreter mode:
>> 
>> java.lang.NullPointerException: Cannot read the array length because "<parameter2>" is null
>>         at compiler.exceptions.StackFrameInFastThrow.throwImplicitException(StackFrameInFastThrow.java:76)
>>         at compiler.exceptions.StackFrameInFastThrow.level2(StackFrameInFastThrow.java:95)
>>         at compiler.exceptions.StackFrameInFastThrow.level1(StackFrameInFastThrow.java:99)
>>         at compiler.exceptions.StackFrameInFastThrow.main(StackFrameInFastThrow.java:233)
>> 
>> Once the method gets compiled with `-XX:+OmitStackTraceInFastThrow` the same exception will look as follows:
>> 
>> java.lang.NullPointerException
>> 
>> After this change, if `StackFrameInFastThrow.throwImplicitException()` will be compiled stand alone, we will get:
>> 
>> java.lang.NullPointerException
>>         at compiler.exceptions.StackFrameInFastThrow.throwImplicitException(StackFrameInFastThrow.java:76)
>> 
>> and if `StackFrameInFastThrow.throwImplicitException()` will be inlined into `level2()` and `level2()` into `level1()` we will get the following exception (altough we're still running with `-XX:+OmitStackTraceInFastThrow`):
>> 
>> java.lang.NullPointerException
>>         at compiler.exceptions.StackFrameInFastThrow.throwImplicitException(StackFrameInFastThrow.java:76)
>>         at compiler.exceptions.StackFrameInFastThrow.level2(StackFrameInFastThrow.java:95)
>>         at compiler.exceptions.StackFrameInFastThrow.level1(StackFrameInFastThrow.java:99)
>> 
>> The new functionality is guarded by `-XX:+/-StackFrameInFastThrow`, but switched on by default (I'll create a CSR for the new option once reviewers are comfortable with the change). Notice that the optimization comes at no run-time costs because all the extra work will be done at compile time.
>> 
>> ## Implementation details
>> 
>> - Already the current implementation of `-XX:+OmitStackTraceInFastThrow` potentially lazy-allocates the empty singleton exceptions like AIOOBE in `ciEnv::ArrayStoreException_instance()`. With this change, if running with `-XX:+StackFrameInFastThrow` we will always allocate new exception objects and populate them with the stack frames which are statically available at compile time (see `java_lang_Throwable::fill_in_stack_trace_of_implicit_exception()`).
>> - Because nmethods don't act as strong GC roots, we have to create a global JNI handle for every newly generated exception to prevent GC from collecting them.
>> - In order to avoid a memory leak we have to release these global JNI handles once a nmethod gets unloaded. In order to achieve this, I've added a new section "implicit exceptions" to the nmethod which holds these JNI handles.
>> - While adding the new  "implicit exceptions" section to the corresponding stats (`print_nmethod_stats()` and printing routines (`nmethod::print()`) I realized that a previous change ([JDK-8254231: Implementation of Foreign Linker API (Incubator)](https://bugs.openjdk.java.net/browse/JDK-8254231)) had already introduced a new nmethod section ("native invokers") but missed to add it to the corresponding stats and printing routines so I've added that section as well.
>> - The `#ifdef COMPILER2` guards are only required to not break the `zero`/`minimal` builds.
>> - The JTreg test is using `-XX:PerMethodTrapLimit=0` to handle all implicit exceptions as "hot". This makes the test simpler and at the same time provokes the allocation of more implicit exceptions.
>> - Manually verified that the created Exception objects are freed by GC once the corresponding nmethods have been flushed.
>> - Manual "stress" test with a very small heap and continuous recompilation of methods with explicit exceptions to provoke GCs during compilation didn't reveal any issues.
>
> Volker Simonis has updated the pull request incrementally with one additional commit since the last revision:
> 
>   Create implcit exceptions with an array of StackTraceElements right away instead of creating a backtrace. This prevents that implicit exceptions will keep classes alive due to Java mirrors in the backtrace.

>  for me it's not an enhancement, but a bug fix, in production an exception with no stacktrace is useless and result in hours lost trying to figure out the issue

If we treat it as a bug,  shall we remove `StackFrameInFastThrow'? we can just make this the default behavior of `OmitStackTraceInFastThrow`. 

Why `OmitStackTraceInFastThrow` isn't a c2-exclusive option?  I think it only affects c2.  That flag overrides the existing flag `StackTraceInThrowable`. Let not introduce another flag.  No one would like an exception without a pointer.

test/hotspot/jtreg/compiler/exceptions/StackFrameInFastThrow.java line 26:

> 24:  /*
> 25:  * @test
> 26:  * @bug 9999999

Should this be 8273392? 
'requires' supports boolean expression |. Therefore,  we don't need two annotations.

test/hotspot/jtreg/compiler/exceptions/StackFrameInFastThrow.java line 110:

> 108:     private static void unload(Method m) {
> 109:         Asserts.assertEQ(WB.getMethodCompilationLevel(m), 4, "Method should be compiled at level 4.");
> 110:         if (DEBUG) System.console().readLine();

Is this "press any key" from stdin?   I got problem to invoke it when I set DEBUG=1. 
We better off remove these statements in case it trip test up. 


TEST RESULT: Failed. Execution failed: `main' threw exception: java.lang.NullPointerException: Cannot invoke "java.io.Console.readLine()" because the return value of "java.lang.System.console()" is null

-------------

PR: https://git.openjdk.java.net/jdk/pull/5392