RFR: 8231269: CompileTask::is_unloaded is slow due to JNIHandles type checks [v2]

[Vladimir Ivanov]

On Mon, 31 Mar 2025 18:46:53 GMT, Aleksey Shipilev <shade at openjdk.org> wrote:

>> [JDK-8163511](https://bugs.openjdk.org/browse/JDK-8163511) made the `CompileTask` improvement to avoid blocking class unloading if a relevant compile task is in queue. Current code does a sleight-of-hand to make sure the the `method*` in `CompileTask` are still valid before using them. Still a noble goal, so we keep trying to do this.
>> 
>> The code tries to switch weak JNI handle with a strong one when it wants to capture the holder to block unloading. Since we are reusing the same field, we have to do type checks like `JNIHandles::is_weak_global_handle(_method_holder)`. Unfortunately, that type-check goes all the way to `OopStorage` allocation code to verify the handle is really allocated in the relevant `OopStorage`. This takes internal `OopStorage` locks, and thus is slow.
>> 
>> This issue is clearly visible in Leyden, when there are lots of `CompileTask`-s in the queue, dumped by AOT code loader. It also does not help that `CompileTask::select_task` is effectively quadratic in number of methods in queue, so we end up calling `CompileTask::is_unloaded` very often.
>> 
>> It is possible to mitigate this issue by splitting the related fields into weak and strong ones. But as Kim mentions in the bug, we should not be using JNI handles here at all, and instead go directly for relevant `OopStorage`-s. This is what this PR does, among other things that should hopefully make the whole mechanics clearer.
>> 
>> Additional testing:
>>  - [x] Linux x86_64 server fastdebug, `compiler/classUnloading`, 100x still passes; these tests are sensitive to bugs in this code
>>  - [x] Linux x86_64 server fastdebug, `all`
>>  - [x] Linux AArch64 server fastdebug, `all`
>
> Aleksey Shipilev has updated the pull request with a new target base due to a merge or a rebase. The incremental webrev excludes the unrelated changes brought in by the merge/rebase. The pull request contains three additional commits since the last revision:
> 
>  - Shared utility class for method unload blocking
>  - Merge branch 'master' into JDK-8231269-compile-task-weaks
>  - JNIHandles -> VM(Weak)

Nice! I really like how it shapes out.

src/hotspot/share/runtime/methodUnloadBlocker.inline.hpp line 72:

> 70:   assert(!is_unloaded(), "Pre-condition: should not be unloaded");
> 71: 
> 72:   if (!_weak_handle.is_empty()) {

Does the precondition imply that `!_weak_handle.is_empty()` always hold?

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

PR Comment: https://git.openjdk.org/jdk/pull/24018#issuecomment-2767653397
PR Review Comment: https://git.openjdk.org/jdk/pull/24018#discussion_r2021915508