jdk-sandbox: comparison src/hotspot/share/runtime/thread.cpp

equal deleted inserted replaced

-:84b0544833c4
+:060d9d139109
 *
 */
 #include "precompiled.hpp"
 #include "jvm.h"
+#include "aot/aotLoader.hpp"
 #include "classfile/classLoader.hpp"
 #include "classfile/javaClasses.hpp"
 #include "classfile/moduleEntry.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmSymbols.hpp"
 // ======= Thread ========
 // Support for forcing alignment of thread objects for biased locking
 void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {
 if (UseBiasedLocking) {
-const int alignment = markOopDesc::biased_lock_alignment;
+const size_t alignment = markWord::biased_lock_alignment;
 size_t aligned_size = size + (alignment - sizeof(intptr_t));
 void* real_malloc_addr = throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC)
 : AllocateHeap(aligned_size, flags, CURRENT_PC,
 AllocFailStrategy::RETURN_NULL);
 void* aligned_addr     = align_up(real_malloc_addr, alignment);
 DEBUG_ONLY(_run_state = PRE_CALL_RUN;)
 // stack and get_thread
 set_stack_base(NULL);
 set_stack_size(0);
-set_self_raw_id(0);
 set_lgrp_id(-1);
 DEBUG_ONLY(clear_suspendible_thread();)
 // allocated data structures
 set_osthread(NULL);
 // the handle mark links itself to last_handle_mark
 new HandleMark(this);
 // plain initialization
 debug_only(_owned_locks = NULL;)
-debug_only(_allow_allocation_count = 0;)
+NOT_PRODUCT(_no_safepoint_count = 0;)
-NOT_PRODUCT(_allow_safepoint_count = 0;)
 NOT_PRODUCT(_skip_gcalot = false;)
 _jvmti_env_iteration_count = 0;
 set_allocated_bytes(0);
 _vm_operation_started_count = 0;
 _vm_operation_completed_count = 0;
 _current_pending_monitor = NULL;
 _current_pending_monitor_is_from_java = true;
 _current_waiting_monitor = NULL;
 _num_nested_signal = 0;
-omFreeList = NULL;
+om_free_list = NULL;
-omFreeCount = 0;
+om_free_count = 0;
-omFreeProvision = 32;
+om_free_provision = 32;
-omInUseList = NULL;
+om_in_use_list = NULL;
-omInUseCount = 0;
+om_in_use_count = 0;
 #ifdef ASSERT
 _visited_for_critical_count = false;
 #endif
 // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents
 // we might instead use a stack of ParkEvents that we could provision on-demand.
 // The stack would act as a cache to avoid calls to ParkEvent::Allocate()
 // and ::Release()
 _ParkEvent   = ParkEvent::Allocate(this);
-_SleepEvent  = ParkEvent::Allocate(this);
 _MuxEvent    = ParkEvent::Allocate(this);
 #ifdef CHECK_UNHANDLED_OOPS
 if (CheckUnhandledOops) {
 _unhandled_oops = new UnhandledOops(this);
 }
 #endif // CHECK_UNHANDLED_OOPS
 #ifdef ASSERT
 if (UseBiasedLocking) {
-assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed");
+assert(is_aligned(this, markWord::biased_lock_alignment), "forced alignment of thread object failed");
 assert(this == _real_malloc_address ||
-this == align_up(_real_malloc_address, (int)markOopDesc::biased_lock_alignment),
+this == align_up(_real_malloc_address, markWord::biased_lock_alignment),
 "bug in forced alignment of thread objects");
 }
 #endif // ASSERT
 // Notify the barrier set that a thread is being created. The initial
 assert(last_handle_mark() == NULL, "check we have reached the end");
 // It's possible we can encounter a null _ParkEvent, etc., in stillborn threads.
 // We NULL out the fields for good hygiene.
 ParkEvent::Release(_ParkEvent); _ParkEvent   = NULL;
-ParkEvent::Release(_SleepEvent); _SleepEvent  = NULL;
 ParkEvent::Release(_MuxEvent); _MuxEvent    = NULL;
 delete handle_area();
 delete metadata_handles();
 }
 return true;
 }
-#ifndef PRODUCT
-void JavaThread::record_jump(address target, address instr, const char* file,
-int line) {
-// This should not need to be atomic as the only way for simultaneous
-// updates is via interrupts. Even then this should be rare or non-existent
-// and we don't care that much anyway.
-int index = _jmp_ring_index;
-_jmp_ring_index = (index + 1) & (jump_ring_buffer_size - 1);
-_jmp_ring[index]._target = (intptr_t) target;
-_jmp_ring[index]._instruction = (intptr_t) instr;
-_jmp_ring[index]._file = file;
-_jmp_ring[index]._line = line;
-}
-#endif // PRODUCT
 void Thread::interrupt(Thread* thread) {
 debug_only(check_for_dangling_thread_pointer(thread);)
 os::interrupt(thread);
 }
 st->print(INTPTR_FORMAT, p2i(this));   // print address
 }
 #ifdef ASSERT
 void Thread::print_owned_locks_on(outputStream* st) const {
-Monitor *cur = _owned_locks;
+Mutex* cur = _owned_locks;
 if (cur == NULL) {
 st->print(" (no locks) ");
 } else {
 st->print_cr(" Locks owned:");
 while (cur) {
 cur = cur->next();
 }
 }
 }
-static int ref_use_count  = 0;
+// Checks safepoint allowed and clears unhandled oops at potential safepoints.
+void Thread::check_possible_safepoint() {
-bool Thread::owns_locks_but_compiled_lock() const {
+if (!is_Java_thread()) return;
-for (Monitor *cur = _owned_locks; cur; cur = cur->next()) {
-if (cur != Compile_lock) return true;
+if (_no_safepoint_count > 0) {
-}
+fatal("Possible safepoint reached by thread that does not allow it");
-return false;
+}
-}
+#ifdef CHECK_UNHANDLED_OOPS
+// Clear unhandled oops in JavaThreads so we get a crash right away.
+clear_unhandled_oops();
-#endif
+#endif // CHECK_UNHANDLED_OOPS
+}
-#ifndef PRODUCT
 // The flag: potential_vm_operation notifies if this particular safepoint state could potentially
 // invoke the vm-thread (e.g., an oop allocation). In that case, we also have to make sure that
 // no locks which allow_vm_block's are held
 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) {
-// Check if current thread is allowed to block at a safepoint
+if (!is_Java_thread()) return;
-if (!(_allow_safepoint_count == 0)) {
-fatal("Possible safepoint reached by thread that does not allow it");
+check_possible_safepoint();
-}
-if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) {
+if (((JavaThread*)this)->thread_state() != _thread_in_vm) {
 fatal("LEAF method calling lock?");
 }
-#ifdef ASSERT
+if (potential_vm_operation && !Universe::is_bootstrapping()) {
-if (potential_vm_operation && is_Java_thread()
-&& !Universe::is_bootstrapping()) {
 // Make sure we do not hold any locks that the VM thread also uses.
 // This could potentially lead to deadlocks
-for (Monitor *cur = _owned_locks; cur; cur = cur->next()) {
+for (Mutex* cur = _owned_locks; cur; cur = cur->next()) {
 // Threads_lock is special, since the safepoint synchronization will not start before this is
 // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock,
 // since it is used to transfer control between JavaThreads and the VMThread
 // Do not *exclude* any locks unless you are absolutely sure it is correct. Ask someone else first!
 if ((cur->allow_vm_block() &&
 if (GCALotAtAllSafepoints) {
 // We could enter a safepoint here and thus have a gc
 InterfaceSupport::check_gc_alot();
 }
-#endif
+}
-}
+#endif // ASSERT
-#endif
 bool Thread::is_in_stack(address adr) const {
 assert(Thread::current() == this, "is_in_stack can only be called from current thread");
 address end = os::current_stack_pointer();
 // Allow non Java threads to call this without stack_base
 _processed_thread(NULL),
 _gc_id(GCId::undefined())
 {}
 NamedThread::~NamedThread() {
-if (_name != NULL) {
+FREE_C_HEAP_ARRAY(char, _name);
-FREE_C_HEAP_ARRAY(char, _name);
-_name = NULL;
-}
 }
 void NamedThread::set_name(const char* format, ...) {
 guarantee(_name == NULL, "Only get to set name once.");
 _name = NEW_C_HEAP_ARRAY(char, max_name_len, mtThread);
-guarantee(_name != NULL, "alloc failure");
 va_list ap;
 va_start(ap, format);
 jio_vsnprintf(_name, max_name_len, format, ap);
 va_end(ap);
 }
 }
 }
 }
 }
+// Attempt to enlarge the array for per thread counters.
+jlong* resize_counters_array(jlong* old_counters, int current_size, int new_size) {
+jlong* new_counters = NEW_C_HEAP_ARRAY(jlong, new_size, mtJVMCI);
+if (new_counters == NULL) {
+return NULL;
+}
+if (old_counters == NULL) {
+old_counters = new_counters;
+memset(old_counters, 0, sizeof(jlong) * new_size);
+} else {
+for (int i = 0; i < MIN2((int) current_size, new_size); i++) {
+new_counters[i] = old_counters[i];
+}
+if (new_size > current_size) {
+memset(new_counters + current_size, 0, sizeof(jlong) * (new_size - current_size));
+}
+FREE_C_HEAP_ARRAY(jlong, old_counters);
+}
+return new_counters;
+}
+// Attempt to enlarge the array for per thread counters.
+bool JavaThread::resize_counters(int current_size, int new_size) {
+jlong* new_counters = resize_counters_array(_jvmci_counters, current_size, new_size);
+if (new_counters == NULL) {
+return false;
+} else {
+_jvmci_counters = new_counters;
+return true;
+}
+}
+class VM_JVMCIResizeCounters : public VM_Operation {
+private:
+int _new_size;
+bool _failed;
+public:
+VM_JVMCIResizeCounters(int new_size) : _new_size(new_size), _failed(false) { }
+VMOp_Type type()                  const        { return VMOp_JVMCIResizeCounters; }
+bool allow_nested_vm_operations() const        { return true; }
+void doit() {
+// Resize the old thread counters array
+jlong* new_counters = resize_counters_array(JavaThread::_jvmci_old_thread_counters, JVMCICounterSize, _new_size);
+if (new_counters == NULL) {
+_failed = true;
+return;
+} else {
+JavaThread::_jvmci_old_thread_counters = new_counters;
+}
+// Now resize each threads array
+for (JavaThreadIteratorWithHandle jtiwh; JavaThread *tp = jtiwh.next(); ) {
+if (!tp->resize_counters(JVMCICounterSize, _new_size)) {
+_failed = true;
+break;
+}
+}
+if (!_failed) {
+JVMCICounterSize = _new_size;
+}
+}
+bool failed() { return _failed; }
+};
+bool JavaThread::resize_all_jvmci_counters(int new_size) {
+VM_JVMCIResizeCounters op(new_size);
+VMThread::execute(&op);
+return !op.failed();
+}
 #endif // INCLUDE_JVMCI
 // A JavaThread is a normal Java thread
 void JavaThread::initialize() {
 set_vframe_array_head(NULL);
 set_vframe_array_last(NULL);
 set_deferred_locals(NULL);
 set_deopt_mark(NULL);
 set_deopt_compiled_method(NULL);
-clear_must_deopt_id();
 set_monitor_chunks(NULL);
-set_next(NULL);
 _on_thread_list = false;
 set_thread_state(_thread_new);
 _terminated = _not_terminated;
 _array_for_gc = NULL;
 _suspend_equivalent = false;
 _pending_failed_speculation = 0;
 _pending_transfer_to_interpreter = false;
 _in_retryable_allocation = false;
 _jvmci._alternate_call_target = NULL;
 assert(_jvmci._implicit_exception_pc == NULL, "must be");
+_jvmci_counters = NULL;
 if (JVMCICounterSize > 0) {
-_jvmci_counters = NEW_C_HEAP_ARRAY(jlong, JVMCICounterSize, mtInternal);
+resize_counters(0, (int) JVMCICounterSize);
-memset(_jvmci_counters, 0, sizeof(jlong) * JVMCICounterSize);
-} else {
-_jvmci_counters = NULL;
 }
 #endif // INCLUDE_JVMCI
 _reserved_stack_activation = NULL;  // stack base not known yet
 (void)const_cast<oop&>(_exception_oop = oop(NULL));
 _exception_pc  = 0;
 _interp_only_mode    = 0;
 _special_runtime_exit_condition = _no_async_condition;
 _pending_async_exception = NULL;
 _thread_stat = NULL;
 _thread_stat = new ThreadStatistics();
-_blocked_on_compilation = false;
 _jni_active_critical = 0;
 _pending_jni_exception_check_fn = NULL;
 _do_not_unlock_if_synchronized = false;
 _cached_monitor_info = NULL;
 _parker = Parker::Allocate(this);
+_SleepEvent = ParkEvent::Allocate(this);
-#ifndef PRODUCT
-_jmp_ring_index = 0;
-for (int ji = 0; ji < jump_ring_buffer_size; ji++) {
-record_jump(NULL, NULL, NULL, 0);
-}
-#endif // PRODUCT
 // Setup safepoint state info for this thread
 ThreadSafepointState::create(this);
 debug_only(_java_call_counter = 0);
 void JavaThread::block_if_vm_exited() {
 if (_terminated == _vm_exited) {
 // _vm_exited is set at safepoint, and Threads_lock is never released
 // we will block here forever
-Threads_lock->lock_without_safepoint_check();
+Threads_lock->lock();
 ShouldNotReachHere();
 }
 }
 // JSR166 -- return the parker to the free list
 Parker::Release(_parker);
 _parker = NULL;
+// Return the sleep event to the free list
+ParkEvent::Release(_SleepEvent);
+_SleepEvent = NULL;
 // Free any remaining  previous UnrollBlock
 vframeArray* old_array = vframe_array_last();
 if (old_array != NULL) {
 Deoptimization::UnrollBlock* old_info = old_array->unroll_block();
 (!check_unsafe_error && condition == _async_unsafe_access_error),
 "must have handled the async condition, if no exception");
 }
 void JavaThread::handle_special_runtime_exit_condition(bool check_asyncs) {
-//
 // Check for pending external suspend.
-// If JNIEnv proxies are allowed, don't self-suspend if the target
+if (is_external_suspend_with_lock()) {
-// thread is not the current thread. In older versions of jdbx, jdbx
-// threads could call into the VM with another thread's JNIEnv so we
-// can be here operating on behalf of a suspended thread (4432884).
-bool do_self_suspend = is_external_suspend_with_lock();
-if (do_self_suspend && (!AllowJNIEnvProxy || this == JavaThread::current())) {
 frame_anchor()->make_walkable(this);
 java_suspend_self_with_safepoint_check();
 }
 // We might be here for reasons in addition to the self-suspend request
 // Note only the ThreadInVMfromNative transition can call this function
 // directly and when thread state is _thread_in_native_trans
 void JavaThread::check_safepoint_and_suspend_for_native_trans(JavaThread *thread) {
 assert(thread->thread_state() == _thread_in_native_trans, "wrong state");
-JavaThread *curJT = JavaThread::current();
+assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "Unwalkable stack in native->vm transition");
-bool do_self_suspend = thread->is_external_suspend();
+if (thread->is_external_suspend()) {
-assert(!curJT->has_last_Java_frame() || curJT->frame_anchor()->walkable(), "Unwalkable stack in native->vm transition");
-// If JNIEnv proxies are allowed, don't self-suspend if the target
-// thread is not the current thread. In older versions of jdbx, jdbx
-// threads could call into the VM with another thread's JNIEnv so we
-// can be here operating on behalf of a suspended thread (4432884).
-if (do_self_suspend && (!AllowJNIEnvProxy || curJT == thread)) {
 thread->java_suspend_self_with_safepoint_check();
 } else {
-SafepointMechanism::block_if_requested(curJT);
+SafepointMechanism::block_if_requested(thread);
 }
 JFR_ONLY(SUSPEND_THREAD_CONDITIONAL(thread);)
 }
 for (StackFrameStream fst(this); !fst.is_done(); fst.next()) {
 fst.current()->oops_do(f, cf, fst.register_map());
 }
 }
-// callee_target is never live across a gc point so NULL it here should
-// it still contain a methdOop.
-set_callee_target(NULL);
 assert(vframe_array_head() == NULL, "deopt in progress at a safepoint!");
 // If we have deferred set_locals there might be oops waiting to be
 // written
 GrowableArray<jvmtiDeferredLocalVariableSet*>* list = deferred_locals();
 if (list != NULL) {
 #ifndef PRODUCT
 void JavaThread::print_thread_state_on(outputStream *st) const {
 st->print_cr("   JavaThread state: %s", _get_thread_state_name(_thread_state));
 };
-void JavaThread::print_thread_state() const {
-print_thread_state_on(tty);
-}
 #endif // PRODUCT
 // Called by Threads::print() for VM_PrintThreads operation
 void JavaThread::print_on(outputStream *st, bool print_extended_info) const {
 st->print_raw("\"");
 }
 assert(name_str != NULL, "unexpected NULL thread name");
 return name_str;
 }
-const char* JavaThread::get_threadgroup_name() const {
-debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);)
-oop thread_obj = threadObj();
-if (thread_obj != NULL) {
-oop thread_group = java_lang_Thread::threadGroup(thread_obj);
-if (thread_group != NULL) {
-// ThreadGroup.name can be null
-return java_lang_ThreadGroup::name(thread_group);
-}
-}
-return NULL;
-}
-const char* JavaThread::get_parent_name() const {
-debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);)
-oop thread_obj = threadObj();
-if (thread_obj != NULL) {
-oop thread_group = java_lang_Thread::threadGroup(thread_obj);
-if (thread_group != NULL) {
-oop parent = java_lang_ThreadGroup::parent(thread_group);
-if (parent != NULL) {
-// ThreadGroup.name can be null
-return java_lang_ThreadGroup::name(parent);
-}
-}
-}
-return NULL;
-}
-ThreadPriority JavaThread::java_priority() const {
-oop thr_oop = threadObj();
-if (thr_oop == NULL) return NormPriority; // Bootstrapping
-ThreadPriority priority = java_lang_Thread::priority(thr_oop);
-assert(MinPriority <= priority && priority <= MaxPriority, "sanity check");
-return priority;
-}
 void JavaThread::prepare(jobject jni_thread, ThreadPriority prio) {
 assert(Threads_lock->owner() == Thread::current(), "must have threads lock");
+assert(NoPriority <= prio && prio <= MaxPriority, "sanity check");
 // Link Java Thread object <-> C++ Thread
 // Get the C++ thread object (an oop) from the JNI handle (a jthread)
 // and put it into a new Handle.  The Handle "thread_oop" can then
 // be used to pass the C++ thread object to other methods.
 return in_WordSize(sz / wordSize);
 }
 void JavaThread::popframe_free_preserved_args() {
 assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice");
-FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args);
+FREE_C_HEAP_ARRAY(char, (char*)_popframe_preserved_args);
 _popframe_preserved_args = NULL;
 _popframe_preserved_args_size = 0;
 }
 #ifndef PRODUCT
 public:
 virtual void do_oop(oop* p) { do_oop_work(p); }
 virtual void do_oop(narrowOop* p)  { do_oop_work(p); }
 };
-static void oops_print(frame* f, const RegisterMap *map) {
-PrintAndVerifyOopClosure print;
-f->print_value();
-f->oops_do(&print, NULL, (RegisterMap*)map);
-}
-// Print our all the locations that contain oops and whether they are
-// valid or not.  This useful when trying to find the oldest frame
-// where an oop has gone bad since the frame walk is from youngest to
-// oldest.
-void JavaThread::trace_oops() {
-tty->print_cr("[Trace oops]");
-frames_do(oops_print);
-}
 #ifdef ASSERT
 // Print or validate the layout of stack frames
 void JavaThread::print_frame_layout(int depth, bool validate_only) {
 ResourceMark rm;
 PRESERVE_EXCEPTION_MARK;
 vfst.security_get_caller_frame(depth);
 if (!vfst.at_end()) {
 return vfst.method()->method_holder();
 }
 return NULL;
+}
+// java.lang.Thread.sleep support
+// Returns true if sleep time elapsed as expected, and false
+// if the thread was interrupted.
+bool JavaThread::sleep(jlong millis) {
+assert(this == Thread::current(),  "thread consistency check");
+ParkEvent * const slp = this->_SleepEvent;
+// Because there can be races with thread interruption sending an unpark()
+// to the event, we explicitly reset it here to avoid an immediate return.
+// The actual interrupt state will be checked before we park().
+slp->reset();
+// Thread interruption establishes a happens-before ordering in the
+// Java Memory Model, so we need to ensure we synchronize with the
+// interrupt state.
+OrderAccess::fence();
+jlong prevtime = os::javaTimeNanos();
+for (;;) {
+// interruption has precedence over timing out
+if (os::is_interrupted(this, true)) {
+return false;
+}
+if (millis <= 0) {
+return true;
+}
+{
+ThreadBlockInVM tbivm(this);
+OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */);
+this->set_suspend_equivalent();
+// cleared by handle_special_suspend_equivalent_condition() or
+// java_suspend_self() via check_and_wait_while_suspended()
+slp->park(millis);
+// were we externally suspended while we were waiting?
+this->check_and_wait_while_suspended();
+}
+// Update elapsed time tracking
+jlong newtime = os::javaTimeNanos();
+if (newtime - prevtime < 0) {
+// time moving backwards, should only happen if no monotonic clock
+// not a guarantee() because JVM should not abort on kernel/glibc bugs
+assert(!os::supports_monotonic_clock(),
+"unexpected time moving backwards detected in os::sleep()");
+} else {
+millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
+}
+prevtime = newtime;
+}
 }
 static void compiler_thread_entry(JavaThread* thread, TRAPS) {
 assert(thread->is_Compiler_thread(), "must be compiler thread");
 CompileBroker::compiler_thread_loop();
 //
 // Note: The Threads_lock is currently more widely used than we
 // would like. We are actively migrating Threads_lock uses to other
 // mechanisms in order to reduce Threads_lock contention.
-JavaThread* Threads::_thread_list = NULL;
 int         Threads::_number_of_threads = 0;
 int         Threads::_number_of_non_daemon_threads = 0;
 int         Threads::_return_code = 0;
 uintx       Threads::_thread_claim_token = 1; // Never zero.
 size_t      JavaThread::_stack_size_at_create = 0;
 // All JavaThreads
 #define ALL_JAVA_THREADS(X) DO_JAVA_THREADS(ThreadsSMRSupport::get_java_thread_list(), X)
 // All NonJavaThreads (i.e., every non-JavaThread in the system).
 void Threads::non_java_threads_do(ThreadClosure* tc) {
-NoSafepointVerifier nsv(!SafepointSynchronize::is_at_safepoint(), false);
+NoSafepointVerifier nsv;
 for (NonJavaThread::Iterator njti; !njti.end(); njti.step()) {
 tc->do_thread(njti.current());
 }
 }
 initialize_class(vmSymbols::java_lang_ArrayStoreException(), CHECK);
 initialize_class(vmSymbols::java_lang_ArithmeticException(), CHECK);
 initialize_class(vmSymbols::java_lang_StackOverflowError(), CHECK);
 initialize_class(vmSymbols::java_lang_IllegalMonitorStateException(), CHECK);
 initialize_class(vmSymbols::java_lang_IllegalArgumentException(), CHECK);
+// Eager box cache initialization only if AOT is on and any library is loaded.
+AOTLoader::initialize_box_caches(CHECK);
 }
 void Threads::initialize_jsr292_core_classes(TRAPS) {
 TraceTime timer("Initialize java.lang.invoke classes", TRACETIME_LOG(Info, startuptime));
 if (Arguments::init_agents_at_startup()) {
 create_vm_init_agents();
 }
 // Initialize Threads state
-_thread_list = NULL;
 _number_of_threads = 0;
 _number_of_non_daemon_threads = 0;
 // Initialize global data structures and create system classes in heap
 vm_init_globals();
 #if INCLUDE_JVMCI
 if (JVMCICounterSize > 0) {
-JavaThread::_jvmci_old_thread_counters = NEW_C_HEAP_ARRAY(jlong, JVMCICounterSize, mtInternal);
+JavaThread::_jvmci_old_thread_counters = NEW_C_HEAP_ARRAY(jlong, JVMCICounterSize, mtJVMCI);
 memset(JavaThread::_jvmci_old_thread_counters, 0, sizeof(jlong) * JVMCICounterSize);
 } else {
 JavaThread::_jvmci_old_thread_counters = NULL;
 }
 #endif // INCLUDE_JVMCI
 if (CleanChunkPoolAsync) {
 Chunk::start_chunk_pool_cleaner_task();
 }
 // initialize compiler(s)
 #if defined(COMPILER1) || COMPILER2_OR_JVMCI
 #if INCLUDE_JVMCI
 bool force_JVMCI_intialization = false;
 if (EnableJVMCI) {
 // cache the system and platform class loaders
 SystemDictionary::compute_java_loaders(CHECK_JNI_ERR);
 #if INCLUDE_CDS
-if (DumpSharedSpaces) {
+// capture the module path info from the ModuleEntryTable
-// capture the module path info from the ModuleEntryTable
+ClassLoader::initialize_module_path(THREAD);
-ClassLoader::initialize_module_path(THREAD);
-}
 #endif
 #if INCLUDE_JVMCI
 if (force_JVMCI_intialization) {
 JVMCI::initialize_compiler(CHECK_JNI_ERR);
 JvmtiExport::enter_onload_phase();
 for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) {
 // CDS dumping does not support native JVMTI agent.
 // CDS dumping supports Java agent if the AllowArchivingWithJavaAgent diagnostic option is specified.
-if (DumpSharedSpaces) {
+if (DumpSharedSpaces || DynamicDumpSharedSpaces) {
 if(!agent->is_instrument_lib()) {
 vm_exit_during_cds_dumping("CDS dumping does not support native JVMTI agent, name", agent->name());
 } else if (!AllowArchivingWithJavaAgent) {
 vm_exit_during_cds_dumping(
 "Must enable AllowArchivingWithJavaAgent in order to run Java agent during CDS dumping");
 // The threads lock must be owned at this point
 assert(Threads_lock->owned_by_self(), "must have threads lock");
 BarrierSet::barrier_set()->on_thread_attach(p);
-p->set_next(_thread_list);
-_thread_list = p;
 // Once a JavaThread is added to the Threads list, smr_delete() has
 // to be used to delete it. Otherwise we can just delete it directly.
 p->set_on_thread_list();
 _number_of_threads++;
 Events::log(p, "Thread added: " INTPTR_FORMAT, p2i(p));
 }
 void Threads::remove(JavaThread* p, bool is_daemon) {
-// Reclaim the ObjectMonitors from the omInUseList and omFreeList of the moribund thread.
+// Reclaim the ObjectMonitors from the om_in_use_list and om_free_list of the moribund thread.
-ObjectSynchronizer::omFlush(p);
+ObjectSynchronizer::om_flush(p);
 // Extra scope needed for Thread_lock, so we can check
 // that we do not remove thread without safepoint code notice
 { MonitorLocker ml(Threads_lock);
 assert(ThreadsSMRSupport::get_java_thread_list()->includes(p), "p must be present");
 // Maintain fast thread list
 ThreadsSMRSupport::remove_thread(p);
-JavaThread* current = _thread_list;
-JavaThread* prev    = NULL;
-while (current != p) {
-prev    = current;
-current = current->next();
-}
-if (prev) {
-prev->set_next(current->next());
-} else {
-_thread_list = p->next();
-}
 _number_of_threads--;
 if (!is_daemon) {
 _number_of_non_daemon_threads--;

branch	JEP-349-branch
changeset 58154	060d9d139109
parent 57878	bffba8d6611a
parent 58095	adc72cd1d1f2
child 58156	68031e660872