1 /*
   2  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "logging/logStream.hpp"
  27 #include "memory/allocation.inline.hpp"
  28 #include "runtime/jniHandles.inline.hpp"
  29 #include "runtime/thread.inline.hpp"
  30 #include "runtime/threadSMR.inline.hpp"
  31 #include "services/threadService.hpp"
  32 #include "utilities/globalDefinitions.hpp"
  33 #include "utilities/resourceHash.hpp"
  34 
  35 Monitor*              ThreadsSMRSupport::_delete_lock =
  36                           new Monitor(Monitor::special, "Thread_SMR_delete_lock",
  37                                       false /* allow_vm_block */,
  38                                       Monitor::_safepoint_check_never);
  39 // The '_cnt', '_max' and '_times" fields are enabled via
  40 // -XX:+EnableThreadSMRStatistics:
  41 
  42 // # of parallel threads in _delete_lock->wait().
  43 // Impl note: Hard to imagine > 64K waiting threads so this could be 16-bit,
  44 // but there is no nice 16-bit _FORMAT support.
  45 uint                  ThreadsSMRSupport::_delete_lock_wait_cnt = 0;
  46 
  47 // Max # of parallel threads in _delete_lock->wait().
  48 // Impl note: See _delete_lock_wait_cnt note.
  49 uint                  ThreadsSMRSupport::_delete_lock_wait_max = 0;
  50 
  51 // Flag to indicate when an _delete_lock->notify() is needed.
  52 // Impl note: See _delete_lock_wait_cnt note.
  53 volatile uint         ThreadsSMRSupport::_delete_notify = 0;
  54 
  55 // # of threads deleted over VM lifetime.
  56 // Impl note: Atomically incremented over VM lifetime so use unsigned for more
  57 // range. Unsigned 64-bit would be more future proof, but 64-bit atomic inc
  58 // isn't available everywhere (or is it?).
  59 volatile uint         ThreadsSMRSupport::_deleted_thread_cnt = 0;
  60 
  61 // Max time in millis to delete a thread.
  62 // Impl note: 16-bit might be too small on an overloaded machine. Use
  63 // unsigned since this is a time value. Set via Atomic::cmpxchg() in a
  64 // loop for correctness.
  65 volatile uint         ThreadsSMRSupport::_deleted_thread_time_max = 0;
  66 
  67 // Cumulative time in millis to delete threads.
  68 // Impl note: Atomically added to over VM lifetime so use unsigned for more
  69 // range. Unsigned 64-bit would be more future proof, but 64-bit atomic inc
  70 // isn't available everywhere (or is it?).
  71 volatile uint         ThreadsSMRSupport::_deleted_thread_times = 0;
  72 
  73 ThreadsList* volatile ThreadsSMRSupport::_java_thread_list = new ThreadsList(0);
  74 
  75 // # of ThreadsLists allocated over VM lifetime.
  76 // Impl note: We allocate a new ThreadsList for every thread create and
  77 // every thread delete so we need a bigger type than the
  78 // _deleted_thread_cnt field.
  79 uint64_t              ThreadsSMRSupport::_java_thread_list_alloc_cnt = 1;
  80 
  81 // # of ThreadsLists freed over VM lifetime.
  82 // Impl note: See _java_thread_list_alloc_cnt note.
  83 uint64_t              ThreadsSMRSupport::_java_thread_list_free_cnt = 0;
  84 
  85 // Max size ThreadsList allocated.
  86 // Impl note: Max # of threads alive at one time should fit in unsigned 32-bit.
  87 uint                  ThreadsSMRSupport::_java_thread_list_max = 0;
  88 
  89 // Max # of nested ThreadsLists for a thread.
  90 // Impl note: Hard to imagine > 64K nested ThreadsLists so this could be
  91 // 16-bit, but there is no nice 16-bit _FORMAT support.
  92 uint                  ThreadsSMRSupport::_nested_thread_list_max = 0;
  93 
  94 // # of ThreadsListHandles deleted over VM lifetime.
  95 // Impl note: Atomically incremented over VM lifetime so use unsigned for
  96 // more range. There will be fewer ThreadsListHandles than threads so
  97 // unsigned 32-bit should be fine.
  98 volatile uint         ThreadsSMRSupport::_tlh_cnt = 0;
  99 
 100 // Max time in millis to delete a ThreadsListHandle.
 101 // Impl note: 16-bit might be too small on an overloaded machine. Use
 102 // unsigned since this is a time value. Set via Atomic::cmpxchg() in a
 103 // loop for correctness.
 104 volatile uint         ThreadsSMRSupport::_tlh_time_max = 0;
 105 
 106 // Cumulative time in millis to delete ThreadsListHandles.
 107 // Impl note: Atomically added to over VM lifetime so use unsigned for more
 108 // range. Unsigned 64-bit would be more future proof, but 64-bit atomic inc
 109 // isn't available everywhere (or is it?).
 110 volatile uint         ThreadsSMRSupport::_tlh_times = 0;
 111 
 112 ThreadsList*          ThreadsSMRSupport::_to_delete_list = NULL;
 113 
 114 // # of parallel ThreadsLists on the to-delete list.
 115 // Impl note: Hard to imagine > 64K ThreadsLists needing to be deleted so
 116 // this could be 16-bit, but there is no nice 16-bit _FORMAT support.
 117 uint                  ThreadsSMRSupport::_to_delete_list_cnt = 0;
 118 
 119 // Max # of parallel ThreadsLists on the to-delete list.
 120 // Impl note: See _to_delete_list_cnt note.
 121 uint                  ThreadsSMRSupport::_to_delete_list_max = 0;
 122 
 123 
 124 // 'inline' functions first so the definitions are before first use:
 125 
 126 inline void ThreadsSMRSupport::add_deleted_thread_times(uint add_value) {
 127   Atomic::add(add_value, &_deleted_thread_times);
 128 }
 129 
 130 inline void ThreadsSMRSupport::inc_deleted_thread_cnt() {
 131   Atomic::inc(&_deleted_thread_cnt);
 132 }
 133 
 134 inline void ThreadsSMRSupport::inc_java_thread_list_alloc_cnt() {
 135   _java_thread_list_alloc_cnt++;
 136 }
 137 
 138 inline void ThreadsSMRSupport::update_deleted_thread_time_max(uint new_value) {
 139   while (true) {
 140     uint cur_value = _deleted_thread_time_max;
 141     if (new_value <= cur_value) {
 142       // No need to update max value so we're done.
 143       break;
 144     }
 145     if (Atomic::cmpxchg(new_value, &_deleted_thread_time_max, cur_value) == cur_value) {
 146       // Updated max value so we're done. Otherwise try it all again.
 147       break;
 148     }
 149   }
 150 }
 151 
 152 inline void ThreadsSMRSupport::update_java_thread_list_max(uint new_value) {
 153   if (new_value > _java_thread_list_max) {
 154     _java_thread_list_max = new_value;
 155   }
 156 }
 157 
 158 inline ThreadsList* ThreadsSMRSupport::xchg_java_thread_list(ThreadsList* new_list) {
 159   return (ThreadsList*)Atomic::xchg(new_list, &_java_thread_list);
 160 }
 161 
 162 
 163 // Hash table of pointers found by a scan. Used for collecting hazard
 164 // pointers (ThreadsList references). Also used for collecting JavaThreads
 165 // that are indirectly referenced by hazard ptrs. An instance of this
 166 // class only contains one type of pointer.
 167 //
 168 class ThreadScanHashtable : public CHeapObj<mtThread> {
 169  private:
 170   static bool ptr_equals(void * const& s1, void * const& s2) {
 171     return s1 == s2;
 172   }
 173 
 174   static unsigned int ptr_hash(void * const& s1) {
 175     // 2654435761 = 2^32 * Phi (golden ratio)
 176     return (unsigned int)(((uint32_t)(uintptr_t)s1) * 2654435761u);
 177   }
 178 
 179   int _table_size;
 180   // ResourceHashtable SIZE is specified at compile time so our
 181   // dynamic _table_size is unused for now; 1031 is the first prime
 182   // after 1024.
 183   typedef ResourceHashtable<void *, int, &ThreadScanHashtable::ptr_hash,
 184                             &ThreadScanHashtable::ptr_equals, 1031,
 185                             ResourceObj::C_HEAP, mtThread> PtrTable;
 186   PtrTable * _ptrs;
 187 
 188  public:
 189   // ResourceHashtable is passed to various functions and populated in
 190   // different places so we allocate it using C_HEAP to make it immune
 191   // from any ResourceMarks that happen to be in the code paths.
 192   ThreadScanHashtable(int table_size) : _table_size(table_size), _ptrs(new (ResourceObj::C_HEAP, mtThread) PtrTable()) {}
 193 
 194   ~ThreadScanHashtable() { delete _ptrs; }
 195 
 196   bool has_entry(void *pointer) {
 197     int *val_ptr = _ptrs->get(pointer);
 198     return val_ptr != NULL && *val_ptr == 1;
 199   }
 200 
 201   void add_entry(void *pointer) {
 202     _ptrs->put(pointer, 1);
 203   }
 204 };
 205 
 206 // Closure to gather JavaThreads indirectly referenced by hazard ptrs
 207 // (ThreadsList references) into a hash table. This closure handles part 2
 208 // of the dance - adding all the JavaThreads referenced by the hazard
 209 // pointer (ThreadsList reference) to the hash table.
 210 //
 211 class AddThreadHazardPointerThreadClosure : public ThreadClosure {
 212  private:
 213   ThreadScanHashtable *_table;
 214 
 215  public:
 216   AddThreadHazardPointerThreadClosure(ThreadScanHashtable *table) : _table(table) {}
 217 
 218   virtual void do_thread(Thread *thread) {
 219     if (!_table->has_entry((void*)thread)) {
 220       // The same JavaThread might be on more than one ThreadsList or
 221       // more than one thread might be using the same ThreadsList. In
 222       // either case, we only need a single entry for a JavaThread.
 223       _table->add_entry((void*)thread);
 224     }
 225   }
 226 };
 227 
 228 // Closure to gather JavaThreads indirectly referenced by hazard ptrs
 229 // (ThreadsList references) into a hash table. This closure handles part 1
 230 // of the dance - hazard ptr chain walking and dispatch to another
 231 // closure.
 232 //
 233 class ScanHazardPtrGatherProtectedThreadsClosure : public ThreadClosure {
 234  private:
 235   ThreadScanHashtable *_table;
 236  public:
 237   ScanHazardPtrGatherProtectedThreadsClosure(ThreadScanHashtable *table) : _table(table) {}
 238 
 239   virtual void do_thread(Thread *thread) {
 240     assert_locked_or_safepoint(Threads_lock);
 241 
 242     if (thread == NULL) return;
 243 
 244     // This code races with ThreadsSMRSupport::acquire_stable_list() which
 245     // is lock-free so we have to handle some special situations.
 246     //
 247     ThreadsList *current_list = NULL;
 248     while (true) {
 249       current_list = thread->get_threads_hazard_ptr();
 250       // No hazard ptr so nothing more to do.
 251       if (current_list == NULL) {
 252         assert(thread->get_nested_threads_hazard_ptr() == NULL,
 253                "cannot have a nested hazard ptr with a NULL regular hazard ptr");
 254         return;
 255       }
 256 
 257       // If the hazard ptr is verified as stable (since it is not tagged),
 258       // then it is safe to use.
 259       if (!Thread::is_hazard_ptr_tagged(current_list)) break;
 260 
 261       // The hazard ptr is tagged as not yet verified as being stable
 262       // so we are racing with acquire_stable_list(). This exchange
 263       // attempts to invalidate the hazard ptr. If we win the race,
 264       // then we can ignore this unstable hazard ptr and the other
 265       // thread will retry the attempt to publish a stable hazard ptr.
 266       // If we lose the race, then we retry our attempt to look at the
 267       // hazard ptr.
 268       if (thread->cmpxchg_threads_hazard_ptr(NULL, current_list) == current_list) return;
 269     }
 270 
 271     // The current JavaThread has a hazard ptr (ThreadsList reference)
 272     // which might be _java_thread_list or it might be an older
 273     // ThreadsList that has been removed but not freed. In either case,
 274     // the hazard ptr is protecting all the JavaThreads on that
 275     // ThreadsList.
 276     AddThreadHazardPointerThreadClosure add_cl(_table);
 277     current_list->threads_do(&add_cl);
 278 
 279     // Any NestedThreadsLists are also protecting JavaThreads so
 280     // gather those also; the ThreadsLists may be different.
 281     for (NestedThreadsList* node = thread->get_nested_threads_hazard_ptr();
 282          node != NULL; node = node->next()) {
 283       node->t_list()->threads_do(&add_cl);
 284     }
 285   }
 286 };
 287 
 288 // Closure to gather hazard ptrs (ThreadsList references) into a hash table.
 289 //
 290 class ScanHazardPtrGatherThreadsListClosure : public ThreadClosure {
 291  private:
 292   ThreadScanHashtable *_table;
 293  public:
 294   ScanHazardPtrGatherThreadsListClosure(ThreadScanHashtable *table) : _table(table) {}
 295 
 296   virtual void do_thread(Thread* thread) {
 297     assert_locked_or_safepoint(Threads_lock);
 298 
 299     if (thread == NULL) return;
 300     ThreadsList *threads = thread->get_threads_hazard_ptr();
 301     if (threads == NULL) {
 302       assert(thread->get_nested_threads_hazard_ptr() == NULL,
 303              "cannot have a nested hazard ptr with a NULL regular hazard ptr");
 304       return;
 305     }
 306     // In this closure we always ignore the tag that might mark this
 307     // hazard ptr as not yet verified. If we happen to catch an
 308     // unverified hazard ptr that is subsequently discarded (not
 309     // published), then the only side effect is that we might keep a
 310     // to-be-deleted ThreadsList alive a little longer.
 311     threads = Thread::untag_hazard_ptr(threads);
 312     if (!_table->has_entry((void*)threads)) {
 313       _table->add_entry((void*)threads);
 314     }
 315 
 316     // Any NestedThreadsLists are also protecting JavaThreads so
 317     // gather those also; the ThreadsLists may be different.
 318     for (NestedThreadsList* node = thread->get_nested_threads_hazard_ptr();
 319          node != NULL; node = node->next()) {
 320       threads = node->t_list();
 321       if (!_table->has_entry((void*)threads)) {
 322         _table->add_entry((void*)threads);
 323       }
 324     }
 325   }
 326 };
 327 
 328 // Closure to print JavaThreads that have a hazard ptr (ThreadsList
 329 // reference) that contains an indirect reference to a specific JavaThread.
 330 //
 331 class ScanHazardPtrPrintMatchingThreadsClosure : public ThreadClosure {
 332  private:
 333   JavaThread *_thread;
 334  public:
 335   ScanHazardPtrPrintMatchingThreadsClosure(JavaThread *thread) : _thread(thread) {}
 336 
 337   virtual void do_thread(Thread *thread) {
 338     assert_locked_or_safepoint(Threads_lock);
 339 
 340     if (thread == NULL) return;
 341     ThreadsList *current_list = thread->get_threads_hazard_ptr();
 342     if (current_list == NULL) {
 343       assert(thread->get_nested_threads_hazard_ptr() == NULL,
 344              "cannot have a nested hazard ptr with a NULL regular hazard ptr");
 345       return;
 346     }
 347     // If the hazard ptr is unverified, then ignore it.
 348     if (Thread::is_hazard_ptr_tagged(current_list)) return;
 349 
 350     // The current JavaThread has a hazard ptr (ThreadsList reference)
 351     // which might be _java_thread_list or it might be an older
 352     // ThreadsList that has been removed but not freed. In either case,
 353     // the hazard ptr is protecting all the JavaThreads on that
 354     // ThreadsList, but we only care about matching a specific JavaThread.
 355     JavaThreadIterator jti(current_list);
 356     for (JavaThread *p = jti.first(); p != NULL; p = jti.next()) {
 357       if (p == _thread) {
 358         log_debug(thread, smr)("tid=" UINTX_FORMAT ": ThreadsSMRSupport::smr_delete: thread1=" INTPTR_FORMAT " has a hazard pointer for thread2=" INTPTR_FORMAT, os::current_thread_id(), p2i(thread), p2i(_thread));
 359         break;
 360       }
 361     }
 362 
 363     // Any NestedThreadsLists are also protecting JavaThreads so
 364     // check those also; the ThreadsLists may be different.
 365     for (NestedThreadsList* node = thread->get_nested_threads_hazard_ptr();
 366          node != NULL; node = node->next()) {
 367       JavaThreadIterator jti(node->t_list());
 368       for (JavaThread *p = jti.first(); p != NULL; p = jti.next()) {
 369         if (p == _thread) {
 370           log_debug(thread, smr)("tid=" UINTX_FORMAT ": ThreadsSMRSupport::smr_delete: thread1=" INTPTR_FORMAT " has a nested hazard pointer for thread2=" INTPTR_FORMAT, os::current_thread_id(), p2i(thread), p2i(_thread));
 371           return;
 372         }
 373       }
 374     }
 375   }
 376 };
 377 
 378 
 379 // 'entries + 1' so we always have at least one entry.
 380 ThreadsList::ThreadsList(int entries) : _length(entries), _threads(NEW_C_HEAP_ARRAY(JavaThread*, entries + 1, mtThread)), _next_list(NULL) {
 381   *(JavaThread**)(_threads + entries) = NULL;  // Make sure the extra entry is NULL.
 382 }
 383 
 384 ThreadsList::~ThreadsList() {
 385   FREE_C_HEAP_ARRAY(JavaThread*, _threads);
 386 }
 387 
 388 // Add a JavaThread to a ThreadsList. The returned ThreadsList is a
 389 // new copy of the specified ThreadsList with the specified JavaThread
 390 // appended to the end.
 391 ThreadsList *ThreadsList::add_thread(ThreadsList *list, JavaThread *java_thread) {
 392   const uint index = list->_length;
 393   const uint new_length = index + 1;
 394   const uint head_length = index;
 395   ThreadsList *const new_list = new ThreadsList(new_length);
 396 
 397   if (head_length > 0) {
 398     Copy::disjoint_words((HeapWord*)list->_threads, (HeapWord*)new_list->_threads, head_length);
 399   }
 400   *(JavaThread**)(new_list->_threads + index) = java_thread;
 401 
 402   return new_list;
 403 }
 404 
 405 int ThreadsList::find_index_of_JavaThread(JavaThread *target) {
 406   if (target == NULL) {
 407     return -1;
 408   }
 409   for (uint i = 0; i < length(); i++) {
 410     if (target == thread_at(i)) {
 411       return (int)i;
 412     }
 413   }
 414   return -1;
 415 }
 416 
 417 JavaThread* ThreadsList::find_JavaThread_from_java_tid(jlong java_tid) const {
 418   for (uint i = 0; i < length(); i++) {
 419     JavaThread* thread = thread_at(i);
 420     oop tobj = thread->threadObj();
 421     // Ignore the thread if it hasn't run yet, has exited
 422     // or is starting to exit.
 423     if (tobj != NULL && !thread->is_exiting() &&
 424         java_tid == java_lang_Thread::thread_id(tobj)) {
 425       // found a match
 426       return thread;
 427     }
 428   }
 429   return NULL;
 430 }
 431 
 432 bool ThreadsList::includes(const JavaThread * const p) const {
 433   if (p == NULL) {
 434     return false;
 435   }
 436   for (uint i = 0; i < length(); i++) {
 437     if (thread_at(i) == p) {
 438       return true;
 439     }
 440   }
 441   return false;
 442 }
 443 
 444 // Remove a JavaThread from a ThreadsList. The returned ThreadsList is a
 445 // new copy of the specified ThreadsList with the specified JavaThread
 446 // removed.
 447 ThreadsList *ThreadsList::remove_thread(ThreadsList* list, JavaThread* java_thread) {
 448   assert(list->_length > 0, "sanity");
 449 
 450   uint i = (uint)list->find_index_of_JavaThread(java_thread);
 451   assert(i < list->_length, "did not find JavaThread on the list");
 452   const uint index = i;
 453   const uint new_length = list->_length - 1;
 454   const uint head_length = index;
 455   const uint tail_length = (new_length >= index) ? (new_length - index) : 0;
 456   ThreadsList *const new_list = new ThreadsList(new_length);
 457 
 458   if (head_length > 0) {
 459     Copy::disjoint_words((HeapWord*)list->_threads, (HeapWord*)new_list->_threads, head_length);
 460   }
 461   if (tail_length > 0) {
 462     Copy::disjoint_words((HeapWord*)list->_threads + index + 1, (HeapWord*)new_list->_threads + index, tail_length);
 463   }
 464 
 465   return new_list;
 466 }
 467 
 468 ThreadsListHandle::ThreadsListHandle(Thread *self) : _list(ThreadsSMRSupport::acquire_stable_list(self, /* is_ThreadsListSetter */ false)), _self(self) {
 469   assert(self == Thread::current(), "sanity check");
 470   if (EnableThreadSMRStatistics) {
 471     _timer.start();
 472   }
 473 }
 474 
 475 ThreadsListHandle::~ThreadsListHandle() {
 476   ThreadsSMRSupport::release_stable_list(_self);
 477   if (EnableThreadSMRStatistics) {
 478     _timer.stop();
 479     uint millis = (uint)_timer.milliseconds();
 480     ThreadsSMRSupport::update_tlh_stats(millis);
 481   }
 482 }
 483 
 484 // Convert an internal thread reference to a JavaThread found on the
 485 // associated ThreadsList. This ThreadsListHandle "protects" the
 486 // returned JavaThread *.
 487 //
 488 // If thread_oop_p is not NULL, then the caller wants to use the oop
 489 // after this call so the oop is returned. On success, *jt_pp is set
 490 // to the converted JavaThread * and true is returned. On error,
 491 // returns false.
 492 //
 493 bool ThreadsListHandle::cv_internal_thread_to_JavaThread(jobject jthread,
 494                                                          JavaThread ** jt_pp,
 495                                                          oop * thread_oop_p) {
 496   assert(this->list() != NULL, "must have a ThreadsList");
 497   assert(jt_pp != NULL, "must have a return JavaThread pointer");
 498   // thread_oop_p is optional so no assert()
 499 
 500   // The JVM_* interfaces don't allow a NULL thread parameter; JVM/TI
 501   // allows a NULL thread parameter to signify "current thread" which
 502   // allows us to avoid calling cv_external_thread_to_JavaThread().
 503   // The JVM_* interfaces have no such leeway.
 504 
 505   oop thread_oop = JNIHandles::resolve_non_null(jthread);
 506   // Looks like an oop at this point.
 507   if (thread_oop_p != NULL) {
 508     // Return the oop to the caller; the caller may still want
 509     // the oop even if this function returns false.
 510     *thread_oop_p = thread_oop;
 511   }
 512 
 513   JavaThread *java_thread = java_lang_Thread::thread(thread_oop);
 514   if (java_thread == NULL) {
 515     // The java.lang.Thread does not contain a JavaThread * so it has
 516     // not yet run or it has died.
 517     return false;
 518   }
 519   // Looks like a live JavaThread at this point.
 520 
 521   if (java_thread != JavaThread::current()) {
 522     // jthread is not for the current JavaThread so have to verify
 523     // the JavaThread * against the ThreadsList.
 524     if (EnableThreadSMRExtraValidityChecks && !includes(java_thread)) {
 525       // Not on the JavaThreads list so it is not alive.
 526       return false;
 527     }
 528   }
 529 
 530   // Return a live JavaThread that is "protected" by the
 531   // ThreadsListHandle in the caller.
 532   *jt_pp = java_thread;
 533   return true;
 534 }
 535 
 536 ThreadsListSetter::~ThreadsListSetter() {
 537   if (_target_needs_release) {
 538     // The hazard ptr in the target needs to be released.
 539     ThreadsSMRSupport::release_stable_list(_target);
 540   }
 541 }
 542 
 543 void ThreadsListSetter::set() {
 544   assert(_target->get_threads_hazard_ptr() == NULL, "hazard ptr should not already be set");
 545   (void) ThreadsSMRSupport::acquire_stable_list(_target, /* is_ThreadsListSetter */ true);
 546   _target_needs_release = true;
 547 }
 548 
 549 // Acquire a stable ThreadsList.
 550 //
 551 ThreadsList *ThreadsSMRSupport::acquire_stable_list(Thread *self, bool is_ThreadsListSetter) {
 552   assert(self != NULL, "sanity check");
 553   // acquire_stable_list_nested_path() will grab the Threads_lock
 554   // so let's make sure the ThreadsListHandle is in a safe place.
 555   // ThreadsListSetter cannot make this check on this code path.
 556   debug_only(if (!is_ThreadsListSetter && StrictSafepointChecks) self->check_for_valid_safepoint_state(/* potential_vm_operation */ false);)
 557 
 558   if (self->get_threads_hazard_ptr() == NULL) {
 559     // The typical case is first.
 560     return acquire_stable_list_fast_path(self);
 561   }
 562 
 563   // The nested case is rare.
 564   return acquire_stable_list_nested_path(self);
 565 }
 566 
 567 // Fast path (and lock free) way to acquire a stable ThreadsList.
 568 //
 569 ThreadsList *ThreadsSMRSupport::acquire_stable_list_fast_path(Thread *self) {
 570   assert(self != NULL, "sanity check");
 571   assert(self->get_threads_hazard_ptr() == NULL, "sanity check");
 572   assert(self->get_nested_threads_hazard_ptr() == NULL,
 573          "cannot have a nested hazard ptr with a NULL regular hazard ptr");
 574 
 575   ThreadsList* threads;
 576 
 577   // Stable recording of a hazard ptr for SMR. This code does not use
 578   // locks so its use of the _java_thread_list & _threads_hazard_ptr
 579   // fields is racy relative to code that uses those fields with locks.
 580   // OrderAccess and Atomic functions are used to deal with those races.
 581   //
 582   while (true) {
 583     threads = get_java_thread_list();
 584 
 585     // Publish a tagged hazard ptr to denote that the hazard ptr is not
 586     // yet verified as being stable. Due to the fence after the hazard
 587     // ptr write, it will be sequentially consistent w.r.t. the
 588     // sequentially consistent writes of the ThreadsList, even on
 589     // non-multiple copy atomic machines where stores can be observed
 590     // in different order from different observer threads.
 591     ThreadsList* unverified_threads = Thread::tag_hazard_ptr(threads);
 592     self->set_threads_hazard_ptr(unverified_threads);
 593 
 594     // If _java_thread_list has changed, we have lost a race with
 595     // Threads::add() or Threads::remove() and have to try again.
 596     if (get_java_thread_list() != threads) {
 597       continue;
 598     }
 599 
 600     // We try to remove the tag which will verify the hazard ptr as
 601     // being stable. This exchange can race with a scanning thread
 602     // which might invalidate the tagged hazard ptr to keep it from
 603     // being followed to access JavaThread ptrs. If we lose the race,
 604     // we simply retry. If we win the race, then the stable hazard
 605     // ptr is officially published.
 606     if (self->cmpxchg_threads_hazard_ptr(threads, unverified_threads) == unverified_threads) {
 607       break;
 608     }
 609   }
 610 
 611   // A stable hazard ptr has been published letting other threads know
 612   // that the ThreadsList and the JavaThreads reachable from this list
 613   // are protected and hence they should not be deleted until everyone
 614   // agrees it is safe to do so.
 615 
 616   return threads;
 617 }
 618 
 619 // Acquire a nested stable ThreadsList; this is rare so it uses
 620 // Threads_lock.
 621 //
 622 ThreadsList *ThreadsSMRSupport::acquire_stable_list_nested_path(Thread *self) {
 623   assert(self != NULL, "sanity check");
 624   assert(self->get_threads_hazard_ptr() != NULL,
 625          "cannot have a NULL regular hazard ptr when acquiring a nested hazard ptr");
 626 
 627   // The thread already has a hazard ptr (ThreadsList ref) so we need
 628   // to create a nested ThreadsListHandle with the current ThreadsList
 629   // since it might be different than our current hazard ptr. The need
 630   // for a nested ThreadsListHandle is rare so we do this while holding
 631   // the Threads_lock so we don't race with the scanning code; the code
 632   // is so much simpler this way.
 633 
 634   NestedThreadsList* node;
 635   {
 636     // Only grab the Threads_lock if we don't already own it.
 637     MutexLockerEx ml(Threads_lock->owned_by_self() ? NULL : Threads_lock);
 638     node = new NestedThreadsList(get_java_thread_list());
 639     // We insert at the front of the list to match up with the delete
 640     // in release_stable_list().
 641     node->set_next(self->get_nested_threads_hazard_ptr());
 642     self->set_nested_threads_hazard_ptr(node);
 643     if (EnableThreadSMRStatistics) {
 644       self->inc_nested_threads_hazard_ptr_cnt();
 645       if (self->nested_threads_hazard_ptr_cnt() > _nested_thread_list_max) {
 646         _nested_thread_list_max = self->nested_threads_hazard_ptr_cnt();
 647       }
 648     }
 649   }
 650   log_debug(thread, smr)("tid=" UINTX_FORMAT ": ThreadsSMRSupport::acquire_stable_list: add NestedThreadsList node containing ThreadsList=" INTPTR_FORMAT, os::current_thread_id(), p2i(node->t_list()));
 651 
 652   return node->t_list();
 653 }
 654 
 655 void ThreadsSMRSupport::add_thread(JavaThread *thread){
 656   ThreadsList *new_list = ThreadsList::add_thread(ThreadsSMRSupport::get_java_thread_list(), thread);
 657   if (EnableThreadSMRStatistics) {
 658     ThreadsSMRSupport::inc_java_thread_list_alloc_cnt();
 659     ThreadsSMRSupport::update_java_thread_list_max(new_list->length());
 660   }
 661   // Initial _java_thread_list will not generate a "Threads::add" mesg.
 662   log_debug(thread, smr)("tid=" UINTX_FORMAT ": Threads::add: new ThreadsList=" INTPTR_FORMAT, os::current_thread_id(), p2i(new_list));
 663 
 664   ThreadsList *old_list = ThreadsSMRSupport::xchg_java_thread_list(new_list);
 665   ThreadsSMRSupport::free_list(old_list);
 666 }
 667 
 668 // set_delete_notify() and clear_delete_notify() are called
 669 // under the protection of the delete_lock, but we also use an
 670 // Atomic operation to ensure the memory update is seen earlier than
 671 // when the delete_lock is dropped.
 672 //
 673 void ThreadsSMRSupport::clear_delete_notify() {
 674   Atomic::dec(&_delete_notify);
 675 }
 676 
 677 bool ThreadsSMRSupport::delete_notify() {
 678   // Use load_acquire() in order to see any updates to _delete_notify
 679   // earlier than when delete_lock is grabbed.
 680   return (OrderAccess::load_acquire(&_delete_notify) != 0);
 681 }
 682 
 683 // Safely free a ThreadsList after a Threads::add() or Threads::remove().
 684 // The specified ThreadsList may not get deleted during this call if it
 685 // is still in-use (referenced by a hazard ptr). Other ThreadsLists
 686 // in the chain may get deleted by this call if they are no longer in-use.
 687 void ThreadsSMRSupport::free_list(ThreadsList* threads) {
 688   assert_locked_or_safepoint(Threads_lock);
 689 
 690   threads->set_next_list(_to_delete_list);
 691   _to_delete_list = threads;
 692   if (EnableThreadSMRStatistics) {
 693     _to_delete_list_cnt++;
 694     if (_to_delete_list_cnt > _to_delete_list_max) {
 695       _to_delete_list_max = _to_delete_list_cnt;
 696     }
 697   }
 698 
 699   // Hash table size should be first power of two higher than twice the length of the ThreadsList
 700   int hash_table_size = MIN2((int)get_java_thread_list()->length(), 32) << 1;
 701   hash_table_size--;
 702   hash_table_size |= hash_table_size >> 1;
 703   hash_table_size |= hash_table_size >> 2;
 704   hash_table_size |= hash_table_size >> 4;
 705   hash_table_size |= hash_table_size >> 8;
 706   hash_table_size |= hash_table_size >> 16;
 707   hash_table_size++;
 708 
 709   // Gather a hash table of the current hazard ptrs:
 710   ThreadScanHashtable *scan_table = new ThreadScanHashtable(hash_table_size);
 711   ScanHazardPtrGatherThreadsListClosure scan_cl(scan_table);
 712   Threads::threads_do(&scan_cl);
 713 
 714   // Walk through the linked list of pending freeable ThreadsLists
 715   // and free the ones that are not referenced from hazard ptrs.
 716   ThreadsList* current = _to_delete_list;
 717   ThreadsList* prev = NULL;
 718   ThreadsList* next = NULL;
 719   bool threads_is_freed = false;
 720   while (current != NULL) {
 721     next = current->next_list();
 722     if (!scan_table->has_entry((void*)current)) {
 723       // This ThreadsList is not referenced by a hazard ptr.
 724       if (prev != NULL) {
 725         prev->set_next_list(next);
 726       }
 727       if (_to_delete_list == current) {
 728         _to_delete_list = next;
 729       }
 730 
 731       log_debug(thread, smr)("tid=" UINTX_FORMAT ": ThreadsSMRSupport::free_list: threads=" INTPTR_FORMAT " is freed.", os::current_thread_id(), p2i(current));
 732       if (current == threads) threads_is_freed = true;
 733       delete current;
 734       if (EnableThreadSMRStatistics) {
 735         _java_thread_list_free_cnt++;
 736         _to_delete_list_cnt--;
 737       }
 738     } else {
 739       prev = current;
 740     }
 741     current = next;
 742   }
 743 
 744   if (!threads_is_freed) {
 745     // Only report "is not freed" on the original call to
 746     // free_list() for this ThreadsList.
 747     log_debug(thread, smr)("tid=" UINTX_FORMAT ": ThreadsSMRSupport::free_list: threads=" INTPTR_FORMAT " is not freed.", os::current_thread_id(), p2i(threads));
 748   }
 749 
 750   delete scan_table;
 751 }
 752 
 753 // Return true if the specified JavaThread is protected by a hazard
 754 // pointer (ThreadsList reference). Otherwise, returns false.
 755 //
 756 bool ThreadsSMRSupport::is_a_protected_JavaThread(JavaThread *thread) {
 757   assert_locked_or_safepoint(Threads_lock);
 758 
 759   // Hash table size should be first power of two higher than twice
 760   // the length of the Threads list.
 761   int hash_table_size = MIN2((int)get_java_thread_list()->length(), 32) << 1;
 762   hash_table_size--;
 763   hash_table_size |= hash_table_size >> 1;
 764   hash_table_size |= hash_table_size >> 2;
 765   hash_table_size |= hash_table_size >> 4;
 766   hash_table_size |= hash_table_size >> 8;
 767   hash_table_size |= hash_table_size >> 16;
 768   hash_table_size++;
 769 
 770   // Gather a hash table of the JavaThreads indirectly referenced by
 771   // hazard ptrs.
 772   ThreadScanHashtable *scan_table = new ThreadScanHashtable(hash_table_size);
 773   ScanHazardPtrGatherProtectedThreadsClosure scan_cl(scan_table);
 774   Threads::threads_do(&scan_cl);
 775 
 776   bool thread_is_protected = false;
 777   if (scan_table->has_entry((void*)thread)) {
 778     thread_is_protected = true;
 779   }
 780   delete scan_table;
 781   return thread_is_protected;
 782 }
 783 
 784 // Release a stable ThreadsList.
 785 //
 786 void ThreadsSMRSupport::release_stable_list(Thread *self) {
 787   assert(self != NULL, "sanity check");
 788   // release_stable_list_nested_path() will grab the Threads_lock
 789   // so let's make sure the ThreadsListHandle is in a safe place.
 790   debug_only(if (StrictSafepointChecks) self->check_for_valid_safepoint_state(/* potential_vm_operation */ false);)
 791 
 792   if (self->get_nested_threads_hazard_ptr() == NULL) {
 793     // The typical case is first.
 794     release_stable_list_fast_path(self);
 795     return;
 796   }
 797 
 798   // The nested case is rare.
 799   release_stable_list_nested_path(self);
 800 }
 801 
 802 // Fast path way to release a stable ThreadsList. The release portion
 803 // is lock-free, but the wake up portion is not.
 804 //
 805 void ThreadsSMRSupport::release_stable_list_fast_path(Thread *self) {
 806   assert(self != NULL, "sanity check");
 807   assert(self->get_threads_hazard_ptr() != NULL, "sanity check");
 808   assert(self->get_nested_threads_hazard_ptr() == NULL,
 809          "cannot have a nested hazard ptr when releasing a regular hazard ptr");
 810 
 811   // After releasing the hazard ptr, other threads may go ahead and
 812   // free up some memory temporarily used by a ThreadsList snapshot.
 813   self->set_threads_hazard_ptr(NULL);
 814 
 815   // We use double-check locking to reduce traffic on the system
 816   // wide Thread-SMR delete_lock.
 817   if (ThreadsSMRSupport::delete_notify()) {
 818     // An exiting thread might be waiting in smr_delete(); we need to
 819     // check with delete_lock to be sure.
 820     release_stable_list_wake_up((char *) "regular hazard ptr");
 821   }
 822 }
 823 
 824 // Release a nested stable ThreadsList; this is rare so it uses
 825 // Threads_lock.
 826 //
 827 void ThreadsSMRSupport::release_stable_list_nested_path(Thread *self) {
 828   assert(self != NULL, "sanity check");
 829   assert(self->get_nested_threads_hazard_ptr() != NULL, "sanity check");
 830   assert(self->get_threads_hazard_ptr() != NULL,
 831          "must have a regular hazard ptr to have nested hazard ptrs");
 832 
 833   // We have a nested ThreadsListHandle so we have to release it first.
 834   // The need for a nested ThreadsListHandle is rare so we do this while
 835   // holding the Threads_lock so we don't race with the scanning code;
 836   // the code is so much simpler this way.
 837 
 838   NestedThreadsList *node;
 839   {
 840     // Only grab the Threads_lock if we don't already own it.
 841     MutexLockerEx ml(Threads_lock->owned_by_self() ? NULL : Threads_lock);
 842     // We remove from the front of the list to match up with the insert
 843     // in acquire_stable_list().
 844     node = self->get_nested_threads_hazard_ptr();
 845     self->set_nested_threads_hazard_ptr(node->next());
 846     if (EnableThreadSMRStatistics) {
 847       self->dec_nested_threads_hazard_ptr_cnt();
 848     }
 849   }
 850 
 851   // An exiting thread might be waiting in smr_delete(); we need to
 852   // check with delete_lock to be sure.
 853   release_stable_list_wake_up((char *) "nested hazard ptr");
 854 
 855   log_debug(thread, smr)("tid=" UINTX_FORMAT ": ThreadsSMRSupport::release_stable_list: delete NestedThreadsList node containing ThreadsList=" INTPTR_FORMAT, os::current_thread_id(), p2i(node->t_list()));
 856 
 857   delete node;
 858 }
 859 
 860 // Wake up portion of the release stable ThreadsList protocol;
 861 // uses the delete_lock().
 862 //
 863 void ThreadsSMRSupport::release_stable_list_wake_up(char *log_str) {
 864   assert(log_str != NULL, "sanity check");
 865 
 866   // Note: delete_lock is held in smr_delete() for the entire
 867   // hazard ptr search so that we do not lose this notify() if
 868   // the exiting thread has to wait. That code path also holds
 869   // Threads_lock (which was grabbed before delete_lock) so that
 870   // threads_do() can be called. This means the system can't start a
 871   // safepoint which means this thread can't take too long to get to
 872   // a safepoint because of being blocked on delete_lock.
 873   //
 874   MonitorLockerEx ml(ThreadsSMRSupport::delete_lock(), Monitor::_no_safepoint_check_flag);
 875   if (ThreadsSMRSupport::delete_notify()) {
 876     // Notify any exiting JavaThreads that are waiting in smr_delete()
 877     // that we've released a ThreadsList.
 878     ml.notify_all();
 879     log_debug(thread, smr)("tid=" UINTX_FORMAT ": ThreadsSMRSupport::release_stable_list notified %s", os::current_thread_id(), log_str);
 880   }
 881 }
 882 
 883 void ThreadsSMRSupport::remove_thread(JavaThread *thread) {
 884   ThreadsList *new_list = ThreadsList::remove_thread(ThreadsSMRSupport::get_java_thread_list(), thread);
 885   if (EnableThreadSMRStatistics) {
 886     ThreadsSMRSupport::inc_java_thread_list_alloc_cnt();
 887     // This list is smaller so no need to check for a "longest" update.
 888   }
 889 
 890   // Final _java_thread_list will not generate a "Threads::remove" mesg.
 891   log_debug(thread, smr)("tid=" UINTX_FORMAT ": Threads::remove: new ThreadsList=" INTPTR_FORMAT, os::current_thread_id(), p2i(new_list));
 892 
 893   ThreadsList *old_list = ThreadsSMRSupport::xchg_java_thread_list(new_list);
 894   ThreadsSMRSupport::free_list(old_list);
 895 }
 896 
 897 // See note for clear_delete_notify().
 898 //
 899 void ThreadsSMRSupport::set_delete_notify() {
 900   Atomic::inc(&_delete_notify);
 901 }
 902 
 903 // Safely delete a JavaThread when it is no longer in use by a
 904 // ThreadsListHandle.
 905 //
 906 void ThreadsSMRSupport::smr_delete(JavaThread *thread) {
 907   assert(!Threads_lock->owned_by_self(), "sanity");
 908 
 909   bool has_logged_once = false;
 910   elapsedTimer timer;
 911   if (EnableThreadSMRStatistics) {
 912     timer.start();
 913   }
 914 
 915   while (true) {
 916     {
 917       // No safepoint check because this JavaThread is not on the
 918       // Threads list.
 919       MutexLockerEx ml(Threads_lock, Mutex::_no_safepoint_check_flag);
 920       // Cannot use a MonitorLockerEx helper here because we have
 921       // to drop the Threads_lock first if we wait.
 922       ThreadsSMRSupport::delete_lock()->lock_without_safepoint_check();
 923       // Set the delete_notify flag after we grab delete_lock
 924       // and before we scan hazard ptrs because we're doing
 925       // double-check locking in release_stable_list().
 926       ThreadsSMRSupport::set_delete_notify();
 927 
 928       if (!is_a_protected_JavaThread(thread)) {
 929         // This is the common case.
 930         ThreadsSMRSupport::clear_delete_notify();
 931         ThreadsSMRSupport::delete_lock()->unlock();
 932         break;
 933       }
 934       if (!has_logged_once) {
 935         has_logged_once = true;
 936         log_debug(thread, smr)("tid=" UINTX_FORMAT ": ThreadsSMRSupport::smr_delete: thread=" INTPTR_FORMAT " is not deleted.", os::current_thread_id(), p2i(thread));
 937         if (log_is_enabled(Debug, os, thread)) {
 938           ScanHazardPtrPrintMatchingThreadsClosure scan_cl(thread);
 939           Threads::threads_do(&scan_cl);
 940         }
 941       }
 942     } // We have to drop the Threads_lock to wait or delete the thread
 943 
 944     if (EnableThreadSMRStatistics) {
 945       _delete_lock_wait_cnt++;
 946       if (_delete_lock_wait_cnt > _delete_lock_wait_max) {
 947         _delete_lock_wait_max = _delete_lock_wait_cnt;
 948       }
 949     }
 950     // Wait for a release_stable_list() call before we check again. No
 951     // safepoint check, no timeout, and not as suspend equivalent flag
 952     // because this JavaThread is not on the Threads list.
 953     ThreadsSMRSupport::delete_lock()->wait(Mutex::_no_safepoint_check_flag, 0,
 954                                      !Mutex::_as_suspend_equivalent_flag);
 955     if (EnableThreadSMRStatistics) {
 956       _delete_lock_wait_cnt--;
 957     }
 958 
 959     ThreadsSMRSupport::clear_delete_notify();
 960     ThreadsSMRSupport::delete_lock()->unlock();
 961     // Retry the whole scenario.
 962   }
 963 
 964   if (ThreadLocalHandshakes) {
 965     // The thread is about to be deleted so cancel any handshake.
 966     thread->cancel_handshake();
 967   }
 968 
 969   delete thread;
 970   if (EnableThreadSMRStatistics) {
 971     timer.stop();
 972     uint millis = (uint)timer.milliseconds();
 973     ThreadsSMRSupport::inc_deleted_thread_cnt();
 974     ThreadsSMRSupport::add_deleted_thread_times(millis);
 975     ThreadsSMRSupport::update_deleted_thread_time_max(millis);
 976   }
 977 
 978   log_debug(thread, smr)("tid=" UINTX_FORMAT ": ThreadsSMRSupport::smr_delete: thread=" INTPTR_FORMAT " is deleted.", os::current_thread_id(), p2i(thread));
 979 }
 980 
 981 
 982 // Debug, logging, and printing stuff at the end:
 983 
 984 // Log Threads class SMR info.
 985 void ThreadsSMRSupport::log_statistics() {
 986   LogTarget(Info, thread, smr) log;
 987   if (log.is_enabled()) {
 988     LogStream out(log);
 989     print_info_on(&out);
 990   }
 991 }
 992 
 993 // Print Threads class SMR info.
 994 void ThreadsSMRSupport::print_info_on(outputStream* st) {
 995   // Only grab the Threads_lock if we don't already own it
 996   // and if we are not reporting an error.
 997   MutexLockerEx ml((Threads_lock->owned_by_self() || VMError::is_error_reported()) ? NULL : Threads_lock);
 998 
 999   st->print_cr("Threads class SMR info:");
1000   st->print_cr("_java_thread_list=" INTPTR_FORMAT ", length=%u, "
1001                "elements={", p2i(_java_thread_list),
1002                _java_thread_list->length());
1003   print_info_elements_on(st, _java_thread_list);
1004   st->print_cr("}");
1005   if (_to_delete_list != NULL) {
1006     st->print_cr("_to_delete_list=" INTPTR_FORMAT ", length=%u, "
1007                  "elements={", p2i(_to_delete_list),
1008                  _to_delete_list->length());
1009     print_info_elements_on(st, _to_delete_list);
1010     st->print_cr("}");
1011     for (ThreadsList *t_list = _to_delete_list->next_list();
1012          t_list != NULL; t_list = t_list->next_list()) {
1013       st->print("next-> " INTPTR_FORMAT ", length=%u, "
1014                 "elements={", p2i(t_list), t_list->length());
1015       print_info_elements_on(st, t_list);
1016       st->print_cr("}");
1017     }
1018   }
1019   if (!EnableThreadSMRStatistics) {
1020     return;
1021   }
1022   st->print_cr("_java_thread_list_alloc_cnt=" UINT64_FORMAT ","
1023                "_java_thread_list_free_cnt=" UINT64_FORMAT ","
1024                "_java_thread_list_max=%u, "
1025                "_nested_thread_list_max=%u",
1026                _java_thread_list_alloc_cnt,
1027                _java_thread_list_free_cnt,
1028                _java_thread_list_max,
1029                _nested_thread_list_max);
1030   if (_tlh_cnt > 0) {
1031     st->print_cr("_tlh_cnt=%u"
1032                  ", _tlh_times=%u"
1033                  ", avg_tlh_time=%0.2f"
1034                  ", _tlh_time_max=%u",
1035                  _tlh_cnt, _tlh_times,
1036                  ((double) _tlh_times / _tlh_cnt),
1037                  _tlh_time_max);
1038   }
1039   if (_deleted_thread_cnt > 0) {
1040     st->print_cr("_deleted_thread_cnt=%u"
1041                  ", _deleted_thread_times=%u"
1042                  ", avg_deleted_thread_time=%0.2f"
1043                  ", _deleted_thread_time_max=%u",
1044                  _deleted_thread_cnt, _deleted_thread_times,
1045                  ((double) _deleted_thread_times / _deleted_thread_cnt),
1046                  _deleted_thread_time_max);
1047   }
1048   st->print_cr("_delete_lock_wait_cnt=%u, _delete_lock_wait_max=%u",
1049                _delete_lock_wait_cnt, _delete_lock_wait_max);
1050   st->print_cr("_to_delete_list_cnt=%u, _to_delete_list_max=%u",
1051                _to_delete_list_cnt, _to_delete_list_max);
1052 }
1053 
1054 // Print ThreadsList elements (4 per line).
1055 void ThreadsSMRSupport::print_info_elements_on(outputStream* st, ThreadsList* t_list) {
1056   uint cnt = 0;
1057   JavaThreadIterator jti(t_list);
1058   for (JavaThread *jt = jti.first(); jt != NULL; jt = jti.next()) {
1059     st->print(INTPTR_FORMAT, p2i(jt));
1060     if (cnt < t_list->length() - 1) {
1061       // Separate with comma or comma-space except for the last one.
1062       if (((cnt + 1) % 4) == 0) {
1063         // Four INTPTR_FORMAT fit on an 80 column line so end the
1064         // current line with just a comma.
1065         st->print_cr(",");
1066       } else {
1067         // Not the last one on the current line so use comma-space:
1068         st->print(", ");
1069       }
1070     } else {
1071       // Last one so just end the current line.
1072       st->cr();
1073     }
1074     cnt++;
1075   }
1076 }