< prev index next >

src/hotspot/share/gc/shared/barrierSet.cpp

Print this page




  36 
  37 public:
  38   SetBarrierSetNonJavaThread(BarrierSet* barrier_set) :
  39     _barrier_set(barrier_set), _count(0) {}
  40 
  41   virtual void do_thread(Thread* thread) {
  42     _barrier_set->on_thread_create(thread);
  43     ++_count;
  44   }
  45 
  46   size_t count() const { return _count; }
  47 };
  48 
  49 void BarrierSet::set_barrier_set(BarrierSet* barrier_set) {
  50   assert(_barrier_set == NULL, "Already initialized");
  51   _barrier_set = barrier_set;
  52 
  53   // Some threads are created before the barrier set, so the call to
  54   // BarrierSet::on_thread_create had to be deferred for them.  Now that
  55   // we have the barrier set, do those deferred calls.



  56 
  57   // First do any non-JavaThreads.
  58   SetBarrierSetNonJavaThread njt_closure(_barrier_set);
  59   Threads::non_java_threads_do(&njt_closure);
  60 
  61   // Do the current (main) thread.  Ensure it's the one and only
  62   // JavaThread so far.  Also verify that it isn't yet on the thread
  63   // list, else we'd also need to call BarrierSet::on_thread_attach.
  64   assert(Thread::current()->is_Java_thread(),
  65          "Expected main thread to be a JavaThread");
  66   assert((njt_closure.count() + 1) == Threads::threads_before_barrier_set(),
  67          "Unexpected JavaThreads before barrier set initialization: "
  68          "Non-JavaThreads: " SIZE_FORMAT ", all: " SIZE_FORMAT,
  69          njt_closure.count(), Threads::threads_before_barrier_set());
  70   assert(!JavaThread::current()->on_thread_list(),
  71          "Main thread already on thread list.");
  72   _barrier_set->on_thread_create(Thread::current());
  73 }
  74 
  75 // Called from init.cpp


  36 
  37 public:
  38   SetBarrierSetNonJavaThread(BarrierSet* barrier_set) :
  39     _barrier_set(barrier_set), _count(0) {}
  40 
  41   virtual void do_thread(Thread* thread) {
  42     _barrier_set->on_thread_create(thread);
  43     ++_count;
  44   }
  45 
  46   size_t count() const { return _count; }
  47 };
  48 
  49 void BarrierSet::set_barrier_set(BarrierSet* barrier_set) {
  50   assert(_barrier_set == NULL, "Already initialized");
  51   _barrier_set = barrier_set;
  52 
  53   // Some threads are created before the barrier set, so the call to
  54   // BarrierSet::on_thread_create had to be deferred for them.  Now that
  55   // we have the barrier set, do those deferred calls.
  56   // Note that this set of threads is 'static' in the sense that they were
  57   // all created earlier by the main thread that is now executing this
  58   // code. No additional threads can be racing to be added to the set.
  59 
  60   // First do any non-JavaThreads.
  61   SetBarrierSetNonJavaThread njt_closure(_barrier_set);
  62   Threads::non_java_threads_do(&njt_closure);
  63 
  64   // Do the current (main) thread.  Ensure it's the one and only
  65   // JavaThread so far.  Also verify that it isn't yet on the thread
  66   // list, else we'd also need to call BarrierSet::on_thread_attach.
  67   assert(Thread::current()->is_Java_thread(),
  68          "Expected main thread to be a JavaThread");
  69   assert((njt_closure.count() + 1) == Threads::threads_before_barrier_set(),
  70          "Unexpected JavaThreads before barrier set initialization: "
  71          "Non-JavaThreads: " SIZE_FORMAT ", all: " SIZE_FORMAT,
  72          njt_closure.count(), Threads::threads_before_barrier_set());
  73   assert(!JavaThread::current()->on_thread_list(),
  74          "Main thread already on thread list.");
  75   _barrier_set->on_thread_create(Thread::current());
  76 }
  77 
  78 // Called from init.cpp
< prev index next >