3375 // the data for WatcherThread is still valid upon being examined. However, 3376 // considering that WatchThread terminates when the VM is on the way to 3377 // exit at safepoint, the chance of the above is extremely small. The right 3378 // way to prevent termination of WatcherThread would be to acquire 3379 // Terminator_lock, but we can't do that without violating the lock rank 3380 // checking in some cases. 3381 if (wt != NULL) { 3382 tc->do_thread(wt); 3383 } 3384 3385 // If CompilerThreads ever become non-JavaThreads, add them here 3386 } 3387 3388 void Threads::parallel_java_threads_do(ThreadClosure* tc) { 3389 int cp = Threads::thread_claim_parity(); 3390 ALL_JAVA_THREADS(p) { 3391 if (p->claim_oops_do(true, cp)) { 3392 tc->do_thread(p); 3393 } 3394 } 3395 } 3396 3397 // The system initialization in the library has three phases. 3398 // 3399 // Phase 1: java.lang.System class initialization 3400 // java.lang.System is a primordial class loaded and initialized 3401 // by the VM early during startup. java.lang.System.<clinit> 3402 // only does registerNatives and keeps the rest of the class 3403 // initialization work later until thread initialization completes. 3404 // 3405 // System.initPhase1 initializes the system properties, the static 3406 // fields in, out, and err. Set up java signal handlers, OS-specific 3407 // system settings, and thread group of the main thread. 3408 static void call_initPhase1(TRAPS) { 3409 Klass* klass = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK); 3410 JavaValue result(T_VOID); 3411 JavaCalls::call_static(&result, klass, vmSymbols::initPhase1_name(), 3412 vmSymbols::void_method_signature(), CHECK); 3413 } 3414 4340 VMThread::vm_thread()->oops_do(f, cf); 4341 } 4342 4343 void Threads::change_thread_claim_parity() { 4344 // Set the new claim parity. 4345 assert(_thread_claim_parity >= 0 && _thread_claim_parity <= 2, 4346 "Not in range."); 4347 _thread_claim_parity++; 4348 if (_thread_claim_parity == 3) _thread_claim_parity = 1; 4349 assert(_thread_claim_parity >= 1 && _thread_claim_parity <= 2, 4350 "Not in range."); 4351 } 4352 4353 #ifdef ASSERT 4354 void Threads::assert_all_threads_claimed() { 4355 ALL_JAVA_THREADS(p) { 4356 const int thread_parity = p->oops_do_parity(); 4357 assert((thread_parity == _thread_claim_parity), 4358 "Thread " PTR_FORMAT " has incorrect parity %d != %d", p2i(p), thread_parity, _thread_claim_parity); 4359 } 4360 } 4361 #endif // ASSERT 4362 4363 void Threads::possibly_parallel_oops_do(bool is_par, OopClosure* f, CodeBlobClosure* cf) { 4364 int cp = Threads::thread_claim_parity(); 4365 ALL_JAVA_THREADS(p) { 4366 if (p->claim_oops_do(is_par, cp)) { 4367 p->oops_do(f, cf); 4368 } 4369 } 4370 VMThread* vmt = VMThread::vm_thread(); 4371 if (vmt->claim_oops_do(is_par, cp)) { 4372 vmt->oops_do(f, cf); 4373 } 4374 } 4375 4376 #if INCLUDE_ALL_GCS 4377 // Used by ParallelScavenge 4378 void Threads::create_thread_roots_tasks(GCTaskQueue* q) { 4379 ALL_JAVA_THREADS(p) { | 3375 // the data for WatcherThread is still valid upon being examined. However, 3376 // considering that WatchThread terminates when the VM is on the way to 3377 // exit at safepoint, the chance of the above is extremely small. The right 3378 // way to prevent termination of WatcherThread would be to acquire 3379 // Terminator_lock, but we can't do that without violating the lock rank 3380 // checking in some cases. 3381 if (wt != NULL) { 3382 tc->do_thread(wt); 3383 } 3384 3385 // If CompilerThreads ever become non-JavaThreads, add them here 3386 } 3387 3388 void Threads::parallel_java_threads_do(ThreadClosure* tc) { 3389 int cp = Threads::thread_claim_parity(); 3390 ALL_JAVA_THREADS(p) { 3391 if (p->claim_oops_do(true, cp)) { 3392 tc->do_thread(p); 3393 } 3394 } 3395 // Thread claiming protocol requires us to claim the same interesting 3396 // threads on all paths. Notably, Threads::possibly_parallel_threads_do 3397 // claims all Java threads *and* the VMThread. To avoid breaking the 3398 // claiming protocol, we have to claim VMThread on this path too, even 3399 // if we do not apply the closure to the VMThread. 3400 VMThread* vmt = VMThread::vm_thread(); 3401 (void)vmt->claim_oops_do(true, cp); 3402 } 3403 3404 // The system initialization in the library has three phases. 3405 // 3406 // Phase 1: java.lang.System class initialization 3407 // java.lang.System is a primordial class loaded and initialized 3408 // by the VM early during startup. java.lang.System.<clinit> 3409 // only does registerNatives and keeps the rest of the class 3410 // initialization work later until thread initialization completes. 3411 // 3412 // System.initPhase1 initializes the system properties, the static 3413 // fields in, out, and err. Set up java signal handlers, OS-specific 3414 // system settings, and thread group of the main thread. 3415 static void call_initPhase1(TRAPS) { 3416 Klass* klass = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK); 3417 JavaValue result(T_VOID); 3418 JavaCalls::call_static(&result, klass, vmSymbols::initPhase1_name(), 3419 vmSymbols::void_method_signature(), CHECK); 3420 } 3421 4347 VMThread::vm_thread()->oops_do(f, cf); 4348 } 4349 4350 void Threads::change_thread_claim_parity() { 4351 // Set the new claim parity. 4352 assert(_thread_claim_parity >= 0 && _thread_claim_parity <= 2, 4353 "Not in range."); 4354 _thread_claim_parity++; 4355 if (_thread_claim_parity == 3) _thread_claim_parity = 1; 4356 assert(_thread_claim_parity >= 1 && _thread_claim_parity <= 2, 4357 "Not in range."); 4358 } 4359 4360 #ifdef ASSERT 4361 void Threads::assert_all_threads_claimed() { 4362 ALL_JAVA_THREADS(p) { 4363 const int thread_parity = p->oops_do_parity(); 4364 assert((thread_parity == _thread_claim_parity), 4365 "Thread " PTR_FORMAT " has incorrect parity %d != %d", p2i(p), thread_parity, _thread_claim_parity); 4366 } 4367 VMThread* vmt = VMThread::vm_thread(); 4368 const int thread_parity = vmt->oops_do_parity(); 4369 assert((thread_parity == _thread_claim_parity), 4370 "VMThread " PTR_FORMAT " has incorrect parity %d != %d", p2i(vmt), thread_parity, _thread_claim_parity); 4371 } 4372 #endif // ASSERT 4373 4374 void Threads::possibly_parallel_oops_do(bool is_par, OopClosure* f, CodeBlobClosure* cf) { 4375 int cp = Threads::thread_claim_parity(); 4376 ALL_JAVA_THREADS(p) { 4377 if (p->claim_oops_do(is_par, cp)) { 4378 p->oops_do(f, cf); 4379 } 4380 } 4381 VMThread* vmt = VMThread::vm_thread(); 4382 if (vmt->claim_oops_do(is_par, cp)) { 4383 vmt->oops_do(f, cf); 4384 } 4385 } 4386 4387 #if INCLUDE_ALL_GCS 4388 // Used by ParallelScavenge 4389 void Threads::create_thread_roots_tasks(GCTaskQueue* q) { 4390 ALL_JAVA_THREADS(p) { |