RFR: 8369238: Allow virtual thread preemption on some common class initialization paths [v9]

[Coleen Phillimore]

On Mon, 27 Oct 2025 19:44:53 GMT, Patricio Chilano Mateo <pchilanomate at openjdk.org> wrote:

>> If a thread tries to initialize a class that is already being initialized by another thread, it will block until notified. Since at this blocking point there are native frames on the stack, a virtual thread cannot be unmounted and is pinned to its carrier. Besides harming scalability, this can, in some pathological cases, lead to a deadlock, for example, if the thread executing the class initialization method is blocked waiting for some unmounted virtual thread to run, but all carriers are blocked waiting for that class to be initialized.
>> 
>> As of JDK-8338383, virtual threads blocked in the VM on `ObjectMonitor` operations can be unmounted. Since synchronization on class initialization is implemented using `ObjectLocker`, we can reuse the same mechanism to unmount virtual threads on these cases too.
>> 
>> This patch adds support for unmounting virtual threads on some of the most common class initialization paths, specifically when calling `InterpreterRuntime::_new` (`new` bytecode), and `InterpreterRuntime::resolve_from_cache` for `invokestatic`, `getstatic` or `putstatic` bytecodes. In the future we might consider extending this mechanism to include initialization calls originating from native methods such as `Class.forName0`.
>> 
>> ### Summary of implementation
>> 
>> The ObjectLocker class was modified to not pin the continuation if we are coming from a preemptable path, which will be the case when calling `InstanceKlass::initialize_impl` from new method `InstanceKlass::initialize_preemptable`. This means that for these cases, a virtual thread can now be unmounted either when contending for the init_lock in the `ObjectLocker` constructor, or in the call to `wait_uninterruptibly`. Also, since the call to initialize a class includes a previous call to `link_class` which also uses `ObjectLocker` to protect concurrent calls from multiple threads, we will allow preemption there too.
>> 
>> If preempted, we will throw a pre-allocated exception which will get propagated with the `TRAPS/CHECK` macros all the way back to the VM entry point. The exception will be cleared and on return back to Java the virtual thread will go through the preempt stub and unmount. When running again, at the end of the thaw call we will identify this preemption case and redo the original VM call (either `InterpreterRuntime::_new` or `InterpreterRuntime::resolve_from_cache`). 
>> 
>> ### Notes
>> 
>> `InterpreterRuntime::call_VM_preemptable` used previously only for `InterpreterRuntime::mon...
>
> Patricio Chilano Mateo has updated the pull request incrementally with one additional commit since the last revision:
> 
>   Improve comment in anchor_mark_set_pd

I had a very small comment that I noticed, but this looks great.  Excellent work solving this class initialization problem for virtual threads.

src/hotspot/share/runtime/continuationFreezeThaw.cpp line 1796:

> 1794: }
> 1795: 
> 1796: static void log_preempt_after_freeze(ContinuationWrapper& cont) {

Does this modify ContinuationWrapper?  I don't see how it does.  If not, it should be a const reference.

src/hotspot/share/runtime/continuationFreezeThaw.cpp line 2680:

> 2678: }
> 2679: 
> 2680: intptr_t* ThawBase::redo_vmcall(JavaThread* current, frame& top) {

Does this modify "top"?  Else should be a const reference too. Looks like a lot of references are non-const.  If these methods don't modify their non-const reference parameters, I think you should have a cleanup pass to fix these to be const references.

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

Marked as reviewed by coleenp (Reviewer).

PR Review: https://git.openjdk.org/jdk/pull/27802#pullrequestreview-3385513965
PR Review Comment: https://git.openjdk.org/jdk/pull/27802#discussion_r2467117304
PR Review Comment: https://git.openjdk.org/jdk/pull/27802#discussion_r2467122440