archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 07:14:30 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8253180: ZGC: Implementation of JEP 376: ZGC: Concurrent Thread-Stack Processing

Browse source 
Reviewed-by: stefank, pliden, rehn, neliasso, coleenp, smonteith
This commit is contained in:
Erik Österlund 2020-10-09 08:40:33 +00:00
parent a2f651904d
commit b9873e1833
131 changed files with 2428 additions and 572 deletions
Download patch file Download diff file Expand all files Collapse all files

24
src/hotspot/share/interpreter/interpreterRuntime.cpp
View file

@ -64,6 +64,7 @@
#include "runtime/jfieldIDWorkaround.hpp"
#include "runtime/osThread.hpp"
#include "runtime/sharedRuntime.hpp"
#include "runtime/stackWatermarkSet.hpp"
#include "runtime/stubRoutines.hpp"
#include "runtime/synchronizer.hpp"
#include "runtime/threadCritical.hpp"
@ -447,6 +448,10 @@ JRT_END
// from a call, the expression stack contains the values for the bci at the
// invoke w/o arguments (i.e., as if one were inside the call).
JRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThread* thread, oopDesc* exception))
// We get here after we have unwound from a callee throwing an exception
// into the interpreter. Any deferred stack processing is notified of
// the event via the StackWatermarkSet.
StackWatermarkSet::after_unwind(thread);
LastFrameAccessor last_frame(thread);
Handle h_exception(thread, exception);
@ -1153,6 +1158,11 @@ JRT_ENTRY(void, InterpreterRuntime::at_safepoint(JavaThread* thread))
// if this is called during a safepoint
if (JvmtiExport::should_post_single_step()) {
// This function is called by the interpreter when single stepping. Such single
// stepping could unwind a frame. Then, it is important that we process any frames
// that we might return into.
StackWatermarkSet::before_unwind(thread);
// We are called during regular safepoints and when the VM is
// single stepping. If any thread is marked for single stepping,
// then we may have JVMTI work to do.
@ -1161,6 +1171,20 @@ JRT_ENTRY(void, InterpreterRuntime::at_safepoint(JavaThread* thread))
}
JRT_END
JRT_ENTRY(void, InterpreterRuntime::at_unwind(JavaThread* thread))
// JRT_END does an implicit safepoint check, hence we are guaranteed to block
// if this is called during a safepoint
// This function is called by the interpreter when the return poll found a reason
// to call the VM. The reason could be that we are returning into a not yet safe
// to access frame. We handle that below.
// Note that this path does not check for single stepping, because we do not want
// to single step when unwinding frames for an exception being thrown. Instead,
// such single stepping code will use the safepoint table, which will use the
// InterpreterRuntime::at_safepoint callback.
StackWatermarkSet::before_unwind(thread);
JRT_END
JRT_ENTRY(void, InterpreterRuntime::post_field_access(JavaThread *thread, oopDesc* obj,
ConstantPoolCacheEntry *cp_entry))