< prev index next >

src/hotspot/share/runtime/thread.cpp

Print this page 
rev 48162 : 8191789: migrate more Thread-SMR stuff from thread.[ch]pp -> threadSMR.[ch]pp
Reviewed-by: stefank
rev 48163 : CR round 0: dcubed - move more code into sort order, add update_smr_tlh_stats(); stefank - refactor Threads::add() and Threads::remove() to allow more ThreadsSMRSupport functions to be private, move is_a_protected_JavaThread_with_lock() to threadSMR.inline.hpp


4350   p->set_next(_thread_list);
4351   _thread_list = p;
4352 
4353   // Once a JavaThread is added to the Threads list, smr_delete() has
4354   // to be used to delete it. Otherwise we can just delete it directly.
4355   p->set_on_thread_list();
4356 
4357   _number_of_threads++;
4358   oop threadObj = p->threadObj();
4359   bool daemon = true;
4360   // Bootstrapping problem: threadObj can be null for initial
4361   // JavaThread (or for threads attached via JNI)
4362   if ((!force_daemon) && (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj))) {
4363     _number_of_non_daemon_threads++;
4364     daemon = false;
4365   }
4366 
4367   ThreadService::add_thread(p, daemon);
4368 
4369   // Maintain fast thread list
4370   ThreadsList *new_list = ThreadsList::add_thread(ThreadsSMRSupport::get_smr_java_thread_list(), p);
4371   if (EnableThreadSMRStatistics) {
4372     ThreadsSMRSupport::inc_smr_java_thread_list_alloc_cnt();
4373     ThreadsSMRSupport::update_smr_java_thread_list_max(new_list->length());
4374   }
4375   // Initial _smr_java_thread_list will not generate a "Threads::add" mesg.
4376   log_debug(thread, smr)("tid=" UINTX_FORMAT ": Threads::add: new ThreadsList=" INTPTR_FORMAT, os::current_thread_id(), p2i(new_list));
4377 
4378   ThreadsList *old_list = ThreadsSMRSupport::xchg_smr_java_thread_list(new_list);
4379   ThreadsSMRSupport::smr_free_list(old_list);
4380 
4381   // Possible GC point.
4382   Events::log(p, "Thread added: " INTPTR_FORMAT, p2i(p));
4383 }
4384 
4385 void Threads::remove(JavaThread* p) {
4386 
4387   // Reclaim the objectmonitors from the omInUseList and omFreeList of the moribund thread.
4388   ObjectSynchronizer::omFlush(p);
4389 
4390   // Extra scope needed for Thread_lock, so we can check
4391   // that we do not remove thread without safepoint code notice
4392   { MutexLocker ml(Threads_lock);
4393 
4394     assert(ThreadsSMRSupport::get_smr_java_thread_list()->includes(p), "p must be present");
4395 
4396     // Maintain fast thread list
4397     ThreadsList *new_list = ThreadsList::remove_thread(ThreadsSMRSupport::get_smr_java_thread_list(), p);
4398     if (EnableThreadSMRStatistics) {
4399       ThreadsSMRSupport::inc_smr_java_thread_list_alloc_cnt();
4400       // This list is smaller so no need to check for a "longest" update.
4401     }
4402 
4403     // Final _smr_java_thread_list will not generate a "Threads::remove" mesg.
4404     log_debug(thread, smr)("tid=" UINTX_FORMAT ": Threads::remove: new ThreadsList=" INTPTR_FORMAT, os::current_thread_id(), p2i(new_list));
4405 
4406     ThreadsList *old_list = ThreadsSMRSupport::xchg_smr_java_thread_list(new_list);
4407     ThreadsSMRSupport::smr_free_list(old_list);
4408 
4409     JavaThread* current = _thread_list;
4410     JavaThread* prev    = NULL;
4411 
4412     while (current != p) {
4413       prev    = current;
4414       current = current->next();
4415     }
4416 
4417     if (prev) {
4418       prev->set_next(current->next());
4419     } else {
4420       _thread_list = p->next();
4421     }
4422 
4423     _number_of_threads--;
4424     oop threadObj = p->threadObj();
4425     bool daemon = true;
4426     if (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj)) {
4427       _number_of_non_daemon_threads--;




4350   p->set_next(_thread_list);
4351   _thread_list = p;
4352 
4353   // Once a JavaThread is added to the Threads list, smr_delete() has
4354   // to be used to delete it. Otherwise we can just delete it directly.
4355   p->set_on_thread_list();
4356 
4357   _number_of_threads++;
4358   oop threadObj = p->threadObj();
4359   bool daemon = true;
4360   // Bootstrapping problem: threadObj can be null for initial
4361   // JavaThread (or for threads attached via JNI)
4362   if ((!force_daemon) && (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj))) {
4363     _number_of_non_daemon_threads++;
4364     daemon = false;
4365   }
4366 
4367   ThreadService::add_thread(p, daemon);
4368 
4369   // Maintain fast thread list
4370   ThreadsSMRSupport::add_thread(p);









4371 
4372   // Possible GC point.
4373   Events::log(p, "Thread added: " INTPTR_FORMAT, p2i(p));
4374 }
4375 
4376 void Threads::remove(JavaThread* p) {
4377 
4378   // Reclaim the objectmonitors from the omInUseList and omFreeList of the moribund thread.
4379   ObjectSynchronizer::omFlush(p);
4380 
4381   // Extra scope needed for Thread_lock, so we can check
4382   // that we do not remove thread without safepoint code notice
4383   { MutexLocker ml(Threads_lock);
4384 
4385     assert(ThreadsSMRSupport::get_smr_java_thread_list()->includes(p), "p must be present");
4386 
4387     // Maintain fast thread list
4388     ThreadsSMRSupport::remove_thread(p);










4389 
4390     JavaThread* current = _thread_list;
4391     JavaThread* prev    = NULL;
4392 
4393     while (current != p) {
4394       prev    = current;
4395       current = current->next();
4396     }
4397 
4398     if (prev) {
4399       prev->set_next(current->next());
4400     } else {
4401       _thread_list = p->next();
4402     }
4403 
4404     _number_of_threads--;
4405     oop threadObj = p->threadObj();
4406     bool daemon = true;
4407     if (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj)) {
4408       _number_of_non_daemon_threads--;
< prev index next >