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

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 *
 */
 #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"
 #endif // ndef DTRACE_ENABLED
 #ifndef USE_LIBRARY_BASED_TLS_ONLY
 // Current thread is maintained as a thread-local variable
-THREAD_LOCAL_DECL Thread* Thread::_thr_current = NULL;
+THREAD_LOCAL Thread* Thread::_thr_current = NULL;
 #endif
 // ======= 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;
+_current_pending_raw_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);
-}
-bool Thread::is_interrupted(Thread* thread, bool clear_interrupted) {
-debug_only(check_for_dangling_thread_pointer(thread);)
-// Note:  If clear_interrupted==false, this simply fetches and
-// returns the value of the field osthread()->interrupted().
-return os::is_interrupted(thread, clear_interrupted);
-}
 // GC Support
 bool Thread::claim_par_threads_do(uintx claim_token) {
 uintx token = _threads_do_token;
 if (token != claim_token) {
 uintx res = Atomic::cmpxchg(claim_token, &_threads_do_token, token);
 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) {
-}
+print_owned_locks();
-return false;
-}
-#endif
-#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 (!(_allow_safepoint_count == 0)) {
 fatal("Possible safepoint reached by thread that does not allow it");
 }
-if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) {
+#ifdef CHECK_UNHANDLED_OOPS
+// Clear unhandled oops in JavaThreads so we get a crash right away.
+clear_unhandled_oops();
+#endif // CHECK_UNHANDLED_OOPS
+}
+void Thread::check_for_valid_safepoint_state() {
+if (!is_Java_thread()) return;
+// Check NoSafepointVerifier, which is implied by locks taken that can be
+// shared with the VM thread.  This makes sure that no locks with allow_vm_block
+// are held.
+check_possible_safepoint();
+if (((JavaThread*)this)->thread_state() != _thread_in_vm) {
 fatal("LEAF method calling lock?");
-}
-#ifdef ASSERT
-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()) {
-// 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() &&
-cur != Threads_lock &&
-cur != Compile_lock &&               // Temporary: should not be necessary when we get separate compilation
-cur != VMOperationRequest_lock &&
-cur != VMOperationQueue_lock) ||
-cur->rank() == Mutex::special) {
-fatal("Thread holding lock at safepoint that vm can block on: %s", cur->name());
-}
-}
 }
 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 (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.
+void JavaThread::resize_counters(int current_size, int new_size) {
+_jvmci_counters = resize_counters_array(_jvmci_counters, current_size, new_size);
+}
+class VM_JVMCIResizeCounters : public VM_Operation {
+private:
+int _new_size;
+public:
+VM_JVMCIResizeCounters(int new_size) : _new_size(new_size) { }
+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);
+JavaThread::_jvmci_old_thread_counters = new_counters;
+// Now resize each threads array
+for (JavaThreadIteratorWithHandle jtiwh; JavaThread *tp = jtiwh.next(); ) {
+tp->resize_counters(JVMCICounterSize, _new_size);
+}
+JVMCICounterSize = _new_size;
+}
+};
+void JavaThread::resize_all_jvmci_counters(int new_size) {
+VM_JVMCIResizeCounters op(new_size);
+VMThread::execute(&op);
+}
 #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);
 _on_thread_list = false;
 set_thread_state(_thread_new);
 _terminated = _not_terminated;
 _array_for_gc = NULL;
 _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);
 _jni_attach_state = _attaching_via_jni;
 } else {
 _jni_attach_state = _not_attaching_via_jni;
 }
 assert(deferred_card_mark().is_empty(), "Default MemRegion ctor");
+}
+// interrupt support
+void JavaThread::interrupt() {
+debug_only(check_for_dangling_thread_pointer(this);)
+if (!osthread()->interrupted()) {
+osthread()->set_interrupted(true);
+// More than one thread can get here with the same value of osthread,
+// resulting in multiple notifications.  We do, however, want the store
+// to interrupted() to be visible to other threads before we execute unpark().
+OrderAccess::fence();
+// For JavaThread::sleep. Historically we only unpark if changing to the interrupted
+// state, in contrast to the other events below. Not clear exactly why.
+_SleepEvent->unpark();
+}
+// For JSR166. Unpark even if interrupt status already was set.
+parker()->unpark();
+// For ObjectMonitor and JvmtiRawMonitor
+_ParkEvent->unpark();
+}
+bool JavaThread::is_interrupted(bool clear_interrupted) {
+debug_only(check_for_dangling_thread_pointer(this);)
+bool interrupted = osthread()->interrupted();
+// NOTE that since there is no "lock" around the interrupt and
+// is_interrupted operations, there is the possibility that the
+// interrupted flag (in osThread) will be "false" but that the
+// low-level events will be in the signaled state. This is
+// intentional. The effect of this is that Object.wait() and
+// LockSupport.park() will appear to have a spurious wakeup, which
+// is allowed and not harmful, and the possibility is so rare that
+// it is not worth the added complexity to add yet another lock.
+// For the sleep event an explicit reset is performed on entry
+// to JavaThread::sleep, so there is no early return. It has also been
+// recommended not to put the interrupted flag into the "event"
+// structure because it hides the issue.
+if (interrupted && clear_interrupted) {
+osthread()->set_interrupted(false);
+// consider thread->_SleepEvent->reset() ... optional optimization
+}
+return interrupted;
 }
 bool JavaThread::reguard_stack(address cur_sp) {
 if (_stack_guard_state != stack_guard_yellow_reserved_disabled
 && _stack_guard_state != stack_guard_reserved_disabled) {
 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
+// we will block here forever.
-Threads_lock->lock_without_safepoint_check();
+// Here we can be doing a jump from a safe state to an unsafe state without
+// proper transition, but it happens after the final safepoint has begun.
+set_thread_state(_thread_in_vm);
+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
 Exceptions::debug_check_abort(_pending_async_exception->klass()->external_name());
 }
 }
-// Interrupt thread so it will wake up from a potential wait()
+// Interrupt thread so it will wake up from a potential wait()/sleep()/park()
-Thread::interrupt(this);
+this->interrupt();
 }
 // External suspension mechanism.
 //
 // Tell the VM to suspend a thread when ever it knows that it does not hold on
 // 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);)
 }
 }
 }
 #endif // PRODUCT
-void JavaThread::deoptimize_marked_methods(bool in_handshake) {
+void JavaThread::deoptimize_marked_methods() {
 if (!has_last_Java_frame()) return;
 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
 StackFrameStream fst(this, UseBiasedLocking);
 for (; !fst.is_done(); fst.next()) {
 if (fst.current()->should_be_deoptimized()) {
-Deoptimization::deoptimize(this, *fst.current(), fst.register_map(), in_handshake);
+Deoptimization::deoptimize(this, *fst.current(), fst.register_map());
 }
 }
 }
 // If the caller is a NamedThread, then remember, in the current scope,
 // Traverse the execution stack
 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();
 #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 (this->is_interrupted(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 JavaThread::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();
 // 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));
 // 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
 JvmtiExport::transition_pending_onload_raw_monitors();
 // Create the VMThread
 { TraceTime timer("Start VMThread", TRACETIME_LOG(Info, startuptime));
 VMThread::create();
 Thread* vmthread = VMThread::vm_thread();
 if (!os::create_thread(vmthread, os::vm_thread)) {
 vm_exit_during_initialization("Cannot create VM thread. "
 "Out of system resources.");
 }
 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;
 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 || DynamicDumpSharedSpaces) {
+if (Arguments::is_dumping_archive()) {
 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");
 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);
 Self->park();
 }
 }
 }
-void Thread::muxAcquireW(volatile intptr_t * Lock, ParkEvent * ev) {
-intptr_t w = Atomic::cmpxchg(LOCKBIT, Lock, (intptr_t)0);
-if (w == 0) return;
-if ((w & LOCKBIT) == 0 && Atomic::cmpxchg(w|LOCKBIT, Lock, w) == w) {
-return;
-}
-ParkEvent * ReleaseAfter = NULL;
-if (ev == NULL) {
-ev = ReleaseAfter = ParkEvent::Allocate(NULL);
-}
-assert((intptr_t(ev) & LOCKBIT) == 0, "invariant");
-for (;;) {
-guarantee(ev->OnList == 0, "invariant");
-int its = (os::is_MP() ? 100 : 0) + 1;
-// Optional spin phase: spin-then-park strategy
-while (--its >= 0) {
-w = *Lock;
-if ((w & LOCKBIT) == 0 && Atomic::cmpxchg(w|LOCKBIT, Lock, w) == w) {
-if (ReleaseAfter != NULL) {
-ParkEvent::Release(ReleaseAfter);
-}
-return;
-}
-}
-ev->reset();
-ev->OnList = intptr_t(Lock);
-// The following fence() isn't _strictly necessary as the subsequent
-// CAS() both serializes execution and ratifies the fetched *Lock value.
-OrderAccess::fence();
-for (;;) {
-w = *Lock;
-if ((w & LOCKBIT) == 0) {
-if (Atomic::cmpxchg(w|LOCKBIT, Lock, w) == w) {
-ev->OnList = 0;
-// We call ::Release while holding the outer lock, thus
-// artificially lengthening the critical section.
-// Consider deferring the ::Release() until the subsequent unlock(),
-// after we've dropped the outer lock.
-if (ReleaseAfter != NULL) {
-ParkEvent::Release(ReleaseAfter);
-}
-return;
-}
-continue;      // Interference -- *Lock changed -- Just retry
-}
-assert(w & LOCKBIT, "invariant");
-ev->ListNext = (ParkEvent *) (w & ~LOCKBIT);
-if (Atomic::cmpxchg(intptr_t(ev)|LOCKBIT, Lock, w) == w) break;
-}
-while (ev->OnList != 0) {
-ev->park();
-}
-}
-}
 // Release() must extract a successor from the list and then wake that thread.
 // It can "pop" the front of the list or use a detach-modify-reattach (DMR) scheme
 // similar to that used by ParkEvent::Allocate() and ::Release().  DMR-based
 // Release() would :
 // (A) CAS() or swap() null to *Lock, releasing the lock and detaching the list.

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 55005	9b70ebd131b4
child 58679	9c3209ff7550