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

rev 52911 : imported patch no_early_njt

*** 24,74 ****
  
  #include "precompiled.hpp"
  #include "gc/shared/barrierSet.hpp"
  #include "gc/shared/barrierSetAssembler.hpp"
  #include "runtime/thread.hpp"
  #include "utilities/macros.hpp"
  
  BarrierSet* BarrierSet::_barrier_set = NULL;
  
- class SetBarrierSetNonJavaThread : public ThreadClosure {
-   BarrierSet* _barrier_set;
-   size_t _count;
- 
- public:
-   SetBarrierSetNonJavaThread(BarrierSet* barrier_set) :
-     _barrier_set(barrier_set), _count(0) {}
- 
-   virtual void do_thread(Thread* thread) {
-     _barrier_set->on_thread_create(thread);
-     ++_count;
-   }
- 
-   size_t count() const { return _count; }
- };
- 
  void BarrierSet::set_barrier_set(BarrierSet* barrier_set) {
    assert(_barrier_set == NULL, "Already initialized");
    _barrier_set = barrier_set;
  
!   // Some threads are created before the barrier set, so the call to
!   // BarrierSet::on_thread_create had to be deferred for them.  Now that
!   // we have the barrier set, do those deferred calls.
! 
!   // First do any non-JavaThreads.
!   SetBarrierSetNonJavaThread njt_closure(_barrier_set);
!   Threads::non_java_threads_do(&njt_closure);
! 
!   // Do the current (main) thread.  Ensure it's the one and only
!   // JavaThread so far.  Also verify that it isn't yet on the thread
    // list, else we'd also need to call BarrierSet::on_thread_attach.
    assert(Thread::current()->is_Java_thread(),
           "Expected main thread to be a JavaThread");
-   assert((njt_closure.count() + 1) == Threads::threads_before_barrier_set(),
-          "Unexpected JavaThreads before barrier set initialization: "
-          "Non-JavaThreads: " SIZE_FORMAT ", all: " SIZE_FORMAT,
-          njt_closure.count(), Threads::threads_before_barrier_set());
    assert(!JavaThread::current()->on_thread_list(),
           "Main thread already on thread list.");
    _barrier_set->on_thread_create(Thread::current());
  }
  
--- 24,51 ----
  
  #include "precompiled.hpp"
  #include "gc/shared/barrierSet.hpp"
  #include "gc/shared/barrierSetAssembler.hpp"
  #include "runtime/thread.hpp"
+ #include "utilities/debug.hpp"
  #include "utilities/macros.hpp"
  
  BarrierSet* BarrierSet::_barrier_set = NULL;
  
  void BarrierSet::set_barrier_set(BarrierSet* barrier_set) {
    assert(_barrier_set == NULL, "Already initialized");
    _barrier_set = barrier_set;
  
!   // Notify barrier set of the current (main) thread.  Normally the
!   // Thread constructor deals with this, but the main thread is
!   // created before we get here.  Verify it isn't yet on the thread
    // list, else we'd also need to call BarrierSet::on_thread_attach.
+   // This is the only thread that can exist at this point; the Thread
+   // constructor objects to other threads being created before the
+   // barrier set is available.
    assert(Thread::current()->is_Java_thread(),
           "Expected main thread to be a JavaThread");
    assert(!JavaThread::current()->on_thread_list(),
           "Main thread already on thread list.");
    _barrier_set->on_thread_create(Thread::current());
  }