750 // retry loop.
751 *bits |= 0x00080000;
752 return false;
753 }
754
755 if (is_suspended) {
756 *bits |= 0x00100000;
757 return true;
758 }
759 } // end retry loop
760
761 // thread did not suspend after all our retries
762 *bits |= 0x00200000;
763 return false;
764 }
765
766 #ifndef PRODUCT
767 void JavaThread::record_jump(address target, address instr, const char* file, int line) {
768
769 // This should not need to be atomic as the only way for simultaneous
770 // updates is via interrupts. Even then this should be rare or non-existant
771 // and we don't care that much anyway.
772
773 int index = _jmp_ring_index;
774 _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1);
775 _jmp_ring[index]._target = (intptr_t) target;
776 _jmp_ring[index]._instruction = (intptr_t) instr;
777 _jmp_ring[index]._file = file;
778 _jmp_ring[index]._line = line;
779 }
780 #endif /* PRODUCT */
781
782 // Called by flat profiler
783 // Callers have already called wait_for_ext_suspend_completion
784 // The assertion for that is currently too complex to put here:
785 bool JavaThread::profile_last_Java_frame(frame* _fr) {
786 bool gotframe = false;
787 // self suspension saves needed state.
788 if (has_last_Java_frame() && _anchor.walkable()) {
789 *_fr = pd_last_frame();
790 gotframe = true;
908 // The flag: potential_vm_operation notifies if this particular safepoint state could potential
909 // invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that
910 // no threads which allow_vm_block's are held
911 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) {
912 // Check if current thread is allowed to block at a safepoint
913 if (!(_allow_safepoint_count == 0))
914 fatal("Possible safepoint reached by thread that does not allow it");
915 if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) {
916 fatal("LEAF method calling lock?");
917 }
918
919 #ifdef ASSERT
920 if (potential_vm_operation && is_Java_thread()
921 && !Universe::is_bootstrapping()) {
922 // Make sure we do not hold any locks that the VM thread also uses.
923 // This could potentially lead to deadlocks
924 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
925 // Threads_lock is special, since the safepoint synchronization will not start before this is
926 // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock,
927 // since it is used to transfer control between JavaThreads and the VMThread
928 // Do not *exclude* any locks unless you are absolutly sure it is correct. Ask someone else first!
929 if ( (cur->allow_vm_block() &&
930 cur != Threads_lock &&
931 cur != Compile_lock && // Temporary: should not be necessary when we get spearate compilation
932 cur != VMOperationRequest_lock &&
933 cur != VMOperationQueue_lock) ||
934 cur->rank() == Mutex::special) {
935 warning("Thread holding lock at safepoint that vm can block on: %s", cur->name());
936 }
937 }
938 }
939
940 if (GCALotAtAllSafepoints) {
941 // We could enter a safepoint here and thus have a gc
942 InterfaceSupport::check_gc_alot();
943 }
944 #endif
945 }
946 #endif
947
948 bool Thread::is_in_stack(address adr) const {
949 assert(Thread::current() == this, "is_in_stack can only be called from current thread");
950 address end = os::current_stack_pointer();
951 // Allow non Java threads to call this without stack_base
1254 // enrolled
1255 int remaining = PeriodicTask::time_to_wait();
1256 int time_slept = 0;
1257
1258 // we expect this to timeout - we only ever get unparked when
1259 // we should terminate or when a new task has been enrolled
1260 OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */);
1261
1262 jlong time_before_loop = os::javaTimeNanos();
1263
1264 for (;;) {
1265 bool timedout = PeriodicTask_lock->wait(Mutex::_no_safepoint_check_flag, remaining);
1266 jlong now = os::javaTimeNanos();
1267
1268 if (remaining == 0) {
1269 // if we didn't have any tasks we could have waited for a long time
1270 // consider the time_slept zero and reset time_before_loop
1271 time_slept = 0;
1272 time_before_loop = now;
1273 } else {
1274 // need to recalulate since we might have new tasks in _tasks
1275 time_slept = (int) ((now - time_before_loop) / 1000000);
1276 }
1277
1278 // Change to task list or spurious wakeup of some kind
1279 if (timedout || _should_terminate) {
1280 break;
1281 }
1282
1283 remaining = PeriodicTask::time_to_wait();
1284 if (remaining == 0) {
1285 // Last task was just disenrolled so loop around and wait until
1286 // another task gets enrolled
1287 continue;
1288 }
1289
1290 remaining -= time_slept;
1291 if (remaining <= 0)
1292 break;
1293 }
1294
1621 jvmtiDeferredLocalVariableSet* dlv = deferred->at(0);
1622 deferred->remove_at(0);
1623 // individual jvmtiDeferredLocalVariableSet are CHeapObj's
1624 delete dlv;
1625 } while (deferred->length() != 0);
1626 delete deferred;
1627 }
1628
1629 // All Java related clean up happens in exit
1630 ThreadSafepointState::destroy(this);
1631 if (_thread_profiler != NULL) delete _thread_profiler;
1632 if (_thread_stat != NULL) delete _thread_stat;
1633 }
1634
1635
1636 // The first routine called by a new Java thread
1637 void JavaThread::run() {
1638 // initialize thread-local alloc buffer related fields
1639 this->initialize_tlab();
1640
1641 // used to test validitity of stack trace backs
1642 this->record_base_of_stack_pointer();
1643
1644 // Record real stack base and size.
1645 this->record_stack_base_and_size();
1646
1647 // Initialize thread local storage; set before calling MutexLocker
1648 this->initialize_thread_local_storage();
1649
1650 this->create_stack_guard_pages();
1651
1652 this->cache_global_variables();
1653
1654 // Thread is now sufficient initialized to be handled by the safepoint code as being
1655 // in the VM. Change thread state from _thread_new to _thread_in_vm
1656 ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm);
1657
1658 assert(JavaThread::current() == this, "sanity check");
1659 assert(!Thread::current()->owns_locks(), "sanity check");
1660
1661 DTRACE_THREAD_PROBE(start, this);
3303
3304 jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
3305
3306 extern void JDK_Version_init();
3307
3308 // Check version
3309 if (!is_supported_jni_version(args->version)) return JNI_EVERSION;
3310
3311 // Initialize the output stream module
3312 ostream_init();
3313
3314 // Process java launcher properties.
3315 Arguments::process_sun_java_launcher_properties(args);
3316
3317 // Initialize the os module before using TLS
3318 os::init();
3319
3320 // Initialize system properties.
3321 Arguments::init_system_properties();
3322
3323 // So that JDK version can be used as a discrimintor when parsing arguments
3324 JDK_Version_init();
3325
3326 // Update/Initialize System properties after JDK version number is known
3327 Arguments::init_version_specific_system_properties();
3328
3329 // Parse arguments
3330 jint parse_result = Arguments::parse(args);
3331 if (parse_result != JNI_OK) return parse_result;
3332
3333 os::init_before_ergo();
3334
3335 jint ergo_result = Arguments::apply_ergo();
3336 if (ergo_result != JNI_OK) return ergo_result;
3337
3338 if (PauseAtStartup) {
3339 os::pause();
3340 }
3341
3342 #ifndef USDT2
3343 HS_DTRACE_PROBE(hotspot, vm__init__begin);
3344 #else /* USDT2 */
3345 HOTSPOT_VM_INIT_BEGIN();
3346 #endif /* USDT2 */
3347
3348 // Record VM creation timing statistics
3349 TraceVmCreationTime create_vm_timer;
3350 create_vm_timer.start();
3351
3352 // Timing (must come after argument parsing)
3353 TraceTime timer("Create VM", TraceStartupTime);
3354
3355 // Initialize the os module after parsing the args
3356 jint os_init_2_result = os::init_2();
3357 if (os_init_2_result != JNI_OK) return os_init_2_result;
3358
3359 jint adjust_after_os_result = Arguments::adjust_after_os();
3360 if (adjust_after_os_result != JNI_OK) return adjust_after_os_result;
3361
3362 // intialize TLS
3363 ThreadLocalStorage::init();
3364
3365 // Bootstrap native memory tracking, so it can start recording memory
3366 // activities before worker thread is started. This is the first phase
3367 // of bootstrapping, VM is currently running in single-thread mode.
3368 MemTracker::bootstrap_single_thread();
3369
3370 // Initialize output stream logging
3371 ostream_init_log();
3372
3373 // Convert -Xrun to -agentlib: if there is no JVM_OnLoad
3374 // Must be before create_vm_init_agents()
3375 if (Arguments::init_libraries_at_startup()) {
3376 convert_vm_init_libraries_to_agents();
3377 }
3378
3379 // Launch -agentlib/-agentpath and converted -Xrun agents
3380 if (Arguments::init_agents_at_startup()) {
3381 create_vm_init_agents();
3382 }
4139
4140 // Since Events::log uses a lock, we grab it outside the Threads_lock
4141 Events::log(p, "Thread exited: " INTPTR_FORMAT, p);
4142 }
4143
4144 // Threads_lock must be held when this is called (or must be called during a safepoint)
4145 bool Threads::includes(JavaThread* p) {
4146 assert(Threads_lock->is_locked(), "sanity check");
4147 ALL_JAVA_THREADS(q) {
4148 if (q == p ) {
4149 return true;
4150 }
4151 }
4152 return false;
4153 }
4154
4155 // Operations on the Threads list for GC. These are not explicitly locked,
4156 // but the garbage collector must provide a safe context for them to run.
4157 // In particular, these things should never be called when the Threads_lock
4158 // is held by some other thread. (Note: the Safepoint abstraction also
4159 // uses the Threads_lock to gurantee this property. It also makes sure that
4160 // all threads gets blocked when exiting or starting).
4161
4162 void Threads::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
4163 ALL_JAVA_THREADS(p) {
4164 p->oops_do(f, cld_f, cf);
4165 }
4166 VMThread::vm_thread()->oops_do(f, cld_f, cf);
4167 }
4168
4169 void Threads::possibly_parallel_oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
4170 // Introduce a mechanism allowing parallel threads to claim threads as
4171 // root groups. Overhead should be small enough to use all the time,
4172 // even in sequential code.
4173 SharedHeap* sh = SharedHeap::heap();
4174 // Cannot yet substitute active_workers for n_par_threads
4175 // because of G1CollectedHeap::verify() use of
4176 // SharedHeap::process_strong_roots(). n_par_threads == 0 will
4177 // turn off parallelism in process_strong_roots while active_workers
4178 // is being used for parallelism elsewhere.
4179 bool is_par = sh->n_par_threads() > 0;
|
750 // retry loop.
751 *bits |= 0x00080000;
752 return false;
753 }
754
755 if (is_suspended) {
756 *bits |= 0x00100000;
757 return true;
758 }
759 } // end retry loop
760
761 // thread did not suspend after all our retries
762 *bits |= 0x00200000;
763 return false;
764 }
765
766 #ifndef PRODUCT
767 void JavaThread::record_jump(address target, address instr, const char* file, int line) {
768
769 // This should not need to be atomic as the only way for simultaneous
770 // updates is via interrupts. Even then this should be rare or non-existent
771 // and we don't care that much anyway.
772
773 int index = _jmp_ring_index;
774 _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1);
775 _jmp_ring[index]._target = (intptr_t) target;
776 _jmp_ring[index]._instruction = (intptr_t) instr;
777 _jmp_ring[index]._file = file;
778 _jmp_ring[index]._line = line;
779 }
780 #endif /* PRODUCT */
781
782 // Called by flat profiler
783 // Callers have already called wait_for_ext_suspend_completion
784 // The assertion for that is currently too complex to put here:
785 bool JavaThread::profile_last_Java_frame(frame* _fr) {
786 bool gotframe = false;
787 // self suspension saves needed state.
788 if (has_last_Java_frame() && _anchor.walkable()) {
789 *_fr = pd_last_frame();
790 gotframe = true;
908 // The flag: potential_vm_operation notifies if this particular safepoint state could potential
909 // invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that
910 // no threads which allow_vm_block's are held
911 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) {
912 // Check if current thread is allowed to block at a safepoint
913 if (!(_allow_safepoint_count == 0))
914 fatal("Possible safepoint reached by thread that does not allow it");
915 if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) {
916 fatal("LEAF method calling lock?");
917 }
918
919 #ifdef ASSERT
920 if (potential_vm_operation && is_Java_thread()
921 && !Universe::is_bootstrapping()) {
922 // Make sure we do not hold any locks that the VM thread also uses.
923 // This could potentially lead to deadlocks
924 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
925 // Threads_lock is special, since the safepoint synchronization will not start before this is
926 // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock,
927 // since it is used to transfer control between JavaThreads and the VMThread
928 // Do not *exclude* any locks unless you are absolutely sure it is correct. Ask someone else first!
929 if ( (cur->allow_vm_block() &&
930 cur != Threads_lock &&
931 cur != Compile_lock && // Temporary: should not be necessary when we get separate compilation
932 cur != VMOperationRequest_lock &&
933 cur != VMOperationQueue_lock) ||
934 cur->rank() == Mutex::special) {
935 warning("Thread holding lock at safepoint that vm can block on: %s", cur->name());
936 }
937 }
938 }
939
940 if (GCALotAtAllSafepoints) {
941 // We could enter a safepoint here and thus have a gc
942 InterfaceSupport::check_gc_alot();
943 }
944 #endif
945 }
946 #endif
947
948 bool Thread::is_in_stack(address adr) const {
949 assert(Thread::current() == this, "is_in_stack can only be called from current thread");
950 address end = os::current_stack_pointer();
951 // Allow non Java threads to call this without stack_base
1254 // enrolled
1255 int remaining = PeriodicTask::time_to_wait();
1256 int time_slept = 0;
1257
1258 // we expect this to timeout - we only ever get unparked when
1259 // we should terminate or when a new task has been enrolled
1260 OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */);
1261
1262 jlong time_before_loop = os::javaTimeNanos();
1263
1264 for (;;) {
1265 bool timedout = PeriodicTask_lock->wait(Mutex::_no_safepoint_check_flag, remaining);
1266 jlong now = os::javaTimeNanos();
1267
1268 if (remaining == 0) {
1269 // if we didn't have any tasks we could have waited for a long time
1270 // consider the time_slept zero and reset time_before_loop
1271 time_slept = 0;
1272 time_before_loop = now;
1273 } else {
1274 // need to recalculate since we might have new tasks in _tasks
1275 time_slept = (int) ((now - time_before_loop) / 1000000);
1276 }
1277
1278 // Change to task list or spurious wakeup of some kind
1279 if (timedout || _should_terminate) {
1280 break;
1281 }
1282
1283 remaining = PeriodicTask::time_to_wait();
1284 if (remaining == 0) {
1285 // Last task was just disenrolled so loop around and wait until
1286 // another task gets enrolled
1287 continue;
1288 }
1289
1290 remaining -= time_slept;
1291 if (remaining <= 0)
1292 break;
1293 }
1294
1621 jvmtiDeferredLocalVariableSet* dlv = deferred->at(0);
1622 deferred->remove_at(0);
1623 // individual jvmtiDeferredLocalVariableSet are CHeapObj's
1624 delete dlv;
1625 } while (deferred->length() != 0);
1626 delete deferred;
1627 }
1628
1629 // All Java related clean up happens in exit
1630 ThreadSafepointState::destroy(this);
1631 if (_thread_profiler != NULL) delete _thread_profiler;
1632 if (_thread_stat != NULL) delete _thread_stat;
1633 }
1634
1635
1636 // The first routine called by a new Java thread
1637 void JavaThread::run() {
1638 // initialize thread-local alloc buffer related fields
1639 this->initialize_tlab();
1640
1641 // used to test validity of stack trace backs
1642 this->record_base_of_stack_pointer();
1643
1644 // Record real stack base and size.
1645 this->record_stack_base_and_size();
1646
1647 // Initialize thread local storage; set before calling MutexLocker
1648 this->initialize_thread_local_storage();
1649
1650 this->create_stack_guard_pages();
1651
1652 this->cache_global_variables();
1653
1654 // Thread is now sufficient initialized to be handled by the safepoint code as being
1655 // in the VM. Change thread state from _thread_new to _thread_in_vm
1656 ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm);
1657
1658 assert(JavaThread::current() == this, "sanity check");
1659 assert(!Thread::current()->owns_locks(), "sanity check");
1660
1661 DTRACE_THREAD_PROBE(start, this);
3303
3304 jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
3305
3306 extern void JDK_Version_init();
3307
3308 // Check version
3309 if (!is_supported_jni_version(args->version)) return JNI_EVERSION;
3310
3311 // Initialize the output stream module
3312 ostream_init();
3313
3314 // Process java launcher properties.
3315 Arguments::process_sun_java_launcher_properties(args);
3316
3317 // Initialize the os module before using TLS
3318 os::init();
3319
3320 // Initialize system properties.
3321 Arguments::init_system_properties();
3322
3323 // So that JDK version can be used as a discriminator when parsing arguments
3324 JDK_Version_init();
3325
3326 // Update/Initialize System properties after JDK version number is known
3327 Arguments::init_version_specific_system_properties();
3328
3329 // Parse arguments
3330 jint parse_result = Arguments::parse(args);
3331 if (parse_result != JNI_OK) return parse_result;
3332
3333 os::init_before_ergo();
3334
3335 jint ergo_result = Arguments::apply_ergo();
3336 if (ergo_result != JNI_OK) return ergo_result;
3337
3338 if (PauseAtStartup) {
3339 os::pause();
3340 }
3341
3342 #ifndef USDT2
3343 HS_DTRACE_PROBE(hotspot, vm__init__begin);
3344 #else /* USDT2 */
3345 HOTSPOT_VM_INIT_BEGIN();
3346 #endif /* USDT2 */
3347
3348 // Record VM creation timing statistics
3349 TraceVmCreationTime create_vm_timer;
3350 create_vm_timer.start();
3351
3352 // Timing (must come after argument parsing)
3353 TraceTime timer("Create VM", TraceStartupTime);
3354
3355 // Initialize the os module after parsing the args
3356 jint os_init_2_result = os::init_2();
3357 if (os_init_2_result != JNI_OK) return os_init_2_result;
3358
3359 jint adjust_after_os_result = Arguments::adjust_after_os();
3360 if (adjust_after_os_result != JNI_OK) return adjust_after_os_result;
3361
3362 // initialize TLS
3363 ThreadLocalStorage::init();
3364
3365 // Bootstrap native memory tracking, so it can start recording memory
3366 // activities before worker thread is started. This is the first phase
3367 // of bootstrapping, VM is currently running in single-thread mode.
3368 MemTracker::bootstrap_single_thread();
3369
3370 // Initialize output stream logging
3371 ostream_init_log();
3372
3373 // Convert -Xrun to -agentlib: if there is no JVM_OnLoad
3374 // Must be before create_vm_init_agents()
3375 if (Arguments::init_libraries_at_startup()) {
3376 convert_vm_init_libraries_to_agents();
3377 }
3378
3379 // Launch -agentlib/-agentpath and converted -Xrun agents
3380 if (Arguments::init_agents_at_startup()) {
3381 create_vm_init_agents();
3382 }
4139
4140 // Since Events::log uses a lock, we grab it outside the Threads_lock
4141 Events::log(p, "Thread exited: " INTPTR_FORMAT, p);
4142 }
4143
4144 // Threads_lock must be held when this is called (or must be called during a safepoint)
4145 bool Threads::includes(JavaThread* p) {
4146 assert(Threads_lock->is_locked(), "sanity check");
4147 ALL_JAVA_THREADS(q) {
4148 if (q == p ) {
4149 return true;
4150 }
4151 }
4152 return false;
4153 }
4154
4155 // Operations on the Threads list for GC. These are not explicitly locked,
4156 // but the garbage collector must provide a safe context for them to run.
4157 // In particular, these things should never be called when the Threads_lock
4158 // is held by some other thread. (Note: the Safepoint abstraction also
4159 // uses the Threads_lock to guarantee this property. It also makes sure that
4160 // all threads gets blocked when exiting or starting).
4161
4162 void Threads::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
4163 ALL_JAVA_THREADS(p) {
4164 p->oops_do(f, cld_f, cf);
4165 }
4166 VMThread::vm_thread()->oops_do(f, cld_f, cf);
4167 }
4168
4169 void Threads::possibly_parallel_oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
4170 // Introduce a mechanism allowing parallel threads to claim threads as
4171 // root groups. Overhead should be small enough to use all the time,
4172 // even in sequential code.
4173 SharedHeap* sh = SharedHeap::heap();
4174 // Cannot yet substitute active_workers for n_par_threads
4175 // because of G1CollectedHeap::verify() use of
4176 // SharedHeap::process_strong_roots(). n_par_threads == 0 will
4177 // turn off parallelism in process_strong_roots while active_workers
4178 // is being used for parallelism elsewhere.
4179 bool is_par = sh->n_par_threads() > 0;
|