src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp

*** 3008,3018 ****
  
    {
      COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;)
      if (CMSParallelInitialMarkEnabled) {
        // The parallel version.
!       FlexibleWorkGang* workers = gch->workers();
        assert(workers != NULL, "Need parallel worker threads.");
        uint n_workers = workers->active_workers();
  
        StrongRootsScope srs(n_workers);
  
--- 3008,3018 ----
  
    {
      COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;)
      if (CMSParallelInitialMarkEnabled) {
        // The parallel version.
!       WorkGang* workers = gch->workers();
        assert(workers != NULL, "Need parallel worker threads.");
        uint n_workers = workers->active_workers();
  
        StrongRootsScope srs(n_workers);
  
*** 4494,4504 ****
   public:
    // A value of 0 passed to n_workers will cause the number of
    // workers to be taken from the active workers in the work gang.
    CMSParRemarkTask(CMSCollector* collector,
                     CompactibleFreeListSpace* cms_space,
!                    uint n_workers, FlexibleWorkGang* workers,
                     OopTaskQueueSet* task_queues,
                     StrongRootsScope* strong_roots_scope):
      CMSParMarkTask("Rescan roots and grey objects in parallel",
                     collector, n_workers),
      _cms_space(cms_space),
--- 4494,4504 ----
   public:
    // A value of 0 passed to n_workers will cause the number of
    // workers to be taken from the active workers in the work gang.
    CMSParRemarkTask(CMSCollector* collector,
                     CompactibleFreeListSpace* cms_space,
!                    uint n_workers, WorkGang* workers,
                     OopTaskQueueSet* task_queues,
                     StrongRootsScope* strong_roots_scope):
      CMSParMarkTask("Rescan roots and grey objects in parallel",
                     collector, n_workers),
      _cms_space(cms_space),
*** 5067,5077 ****
  }
  
  // Parallel version of remark
  void CMSCollector::do_remark_parallel() {
    GenCollectedHeap* gch = GenCollectedHeap::heap();
!   FlexibleWorkGang* workers = gch->workers();
    assert(workers != NULL, "Need parallel worker threads.");
    // Choose to use the number of GC workers most recently set
    // into "active_workers".
    uint n_workers = workers->active_workers();
  
--- 5067,5077 ----
  }
  
  // Parallel version of remark
  void CMSCollector::do_remark_parallel() {
    GenCollectedHeap* gch = GenCollectedHeap::heap();
!   WorkGang* workers = gch->workers();
    assert(workers != NULL, "Need parallel worker threads.");
    // Choose to use the number of GC workers most recently set
    // into "active_workers".
    uint n_workers = workers->active_workers();
  
*** 5242,5251 ****
--- 5242,5261 ----
  }
  
  ////////////////////////////////////////////////////////
  // Parallel Reference Processing Task Proxy Class
  ////////////////////////////////////////////////////////
+ class AbstractGangTaskWOopQueues : public AbstractGangTask {
+   OopTaskQueueSet*       _queues;
+   ParallelTaskTerminator _terminator;
+  public:
+   AbstractGangTaskWOopQueues(const char* name, OopTaskQueueSet* queues, uint n_threads) :
+     AbstractGangTask(name), _queues(queues), _terminator(n_threads, _queues) {}
+   ParallelTaskTerminator* terminator() { return &_terminator; }
+   OopTaskQueueSet* queues() { return _queues; }
+ };
+ 
  class CMSRefProcTaskProxy: public AbstractGangTaskWOopQueues {
    typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask;
    CMSCollector*          _collector;
    CMSBitMap*             _mark_bit_map;
    const MemRegion        _span;
*** 5378,5388 ****
  }
  
  void CMSRefProcTaskExecutor::execute(ProcessTask& task)
  {
    GenCollectedHeap* gch = GenCollectedHeap::heap();
!   FlexibleWorkGang* workers = gch->workers();
    assert(workers != NULL, "Need parallel worker threads.");
    CMSRefProcTaskProxy rp_task(task, &_collector,
                                _collector.ref_processor()->span(),
                                _collector.markBitMap(),
                                workers, _collector.task_queues());
--- 5388,5398 ----
  }
  
  void CMSRefProcTaskExecutor::execute(ProcessTask& task)
  {
    GenCollectedHeap* gch = GenCollectedHeap::heap();
!   WorkGang* workers = gch->workers();
    assert(workers != NULL, "Need parallel worker threads.");
    CMSRefProcTaskProxy rp_task(task, &_collector,
                                _collector.ref_processor()->span(),
                                _collector.markBitMap(),
                                workers, _collector.task_queues());
*** 5391,5401 ****
  
  void CMSRefProcTaskExecutor::execute(EnqueueTask& task)
  {
  
    GenCollectedHeap* gch = GenCollectedHeap::heap();
!   FlexibleWorkGang* workers = gch->workers();
    assert(workers != NULL, "Need parallel worker threads.");
    CMSRefEnqueueTaskProxy enq_task(task);
    workers->run_task(&enq_task);
  }
  
--- 5401,5411 ----
  
  void CMSRefProcTaskExecutor::execute(EnqueueTask& task)
  {
  
    GenCollectedHeap* gch = GenCollectedHeap::heap();
!   WorkGang* workers = gch->workers();
    assert(workers != NULL, "Need parallel worker threads.");
    CMSRefEnqueueTaskProxy enq_task(task);
    workers->run_task(&enq_task);
  }
  
*** 5425,5435 ****
        // and a different number of discovered lists may have Ref objects.
        // That is OK as long as the Reference lists are balanced (see
        // balance_all_queues() and balance_queues()).
        GenCollectedHeap* gch = GenCollectedHeap::heap();
        uint active_workers = ParallelGCThreads;
!       FlexibleWorkGang* workers = gch->workers();
        if (workers != NULL) {
          active_workers = workers->active_workers();
          // The expectation is that active_workers will have already
          // been set to a reasonable value.  If it has not been set,
          // investigate.
--- 5435,5445 ----
        // and a different number of discovered lists may have Ref objects.
        // That is OK as long as the Reference lists are balanced (see
        // balance_all_queues() and balance_queues()).
        GenCollectedHeap* gch = GenCollectedHeap::heap();
        uint active_workers = ParallelGCThreads;
!       WorkGang* workers = gch->workers();
        if (workers != NULL) {
          active_workers = workers->active_workers();
          // The expectation is that active_workers will have already
          // been set to a reasonable value.  If it has not been set,
          // investigate.