src/hotspot/share/gc/g1/g1DirtyCardQueue.cpp

rev 54044 : [mq]: new_shared_dcq

*** 54,78 ****
      // Otherwise, we finished successfully; return true.
      return true;
    }
  };
  
! G1DirtyCardQueue::G1DirtyCardQueue(G1DirtyCardQueueSet* qset, bool permanent) :
    // Dirty card queues are always active, so we create them with their
    // active field set to true.
!   PtrQueue(qset, permanent, true /* active */)
  { }
  
  G1DirtyCardQueue::~G1DirtyCardQueue() {
-   if (!is_permanent()) {
      flush();
-   }
  }
  
  G1DirtyCardQueueSet::G1DirtyCardQueueSet(bool notify_when_complete) :
    PtrQueueSet(notify_when_complete),
-   _shared_dirty_card_queue(this, true /* permanent */),
    _free_ids(NULL),
    _processed_buffers_mut(0),
    _processed_buffers_rs_thread(0),
    _cur_par_buffer_node(NULL)
  {
--- 54,75 ----
      // Otherwise, we finished successfully; return true.
      return true;
    }
  };
  
! G1DirtyCardQueue::G1DirtyCardQueue(G1DirtyCardQueueSet* qset) :
    // Dirty card queues are always active, so we create them with their
    // active field set to true.
!   PtrQueue(qset, true /* active */)
  { }
  
  G1DirtyCardQueue::~G1DirtyCardQueue() {
    flush();
  }
  
  G1DirtyCardQueueSet::G1DirtyCardQueueSet(bool notify_when_complete) :
    PtrQueueSet(notify_when_complete),
    _free_ids(NULL),
    _processed_buffers_mut(0),
    _processed_buffers_rs_thread(0),
    _cur_par_buffer_node(NULL)
  {
*** 88,101 ****
    return (uint)os::initial_active_processor_count();
  }
  
  void G1DirtyCardQueueSet::initialize(Monitor* cbl_mon,
                                       BufferNode::Allocator* allocator,
-                                      Mutex* lock,
                                       bool init_free_ids) {
    PtrQueueSet::initialize(cbl_mon, allocator);
-   _shared_dirty_card_queue.set_lock(lock);
    if (init_free_ids) {
      _free_ids = new G1FreeIdSet(0, num_par_ids());
    }
  }
  
--- 85,96 ----
*** 215,249 ****
        G1ThreadLocalData::dirty_card_queue(t).reset();
      }
    } closure;
    Threads::threads_do(&closure);
  
!   shared_dirty_card_queue()->reset();
! }
! 
! void G1DirtyCardQueueSet::concatenate_log(G1DirtyCardQueue& dcq) {
!   if (!dcq.is_empty()) {
!     dcq.flush();
!   }
  }
  
  void G1DirtyCardQueueSet::concatenate_logs() {
    // Iterate over all the threads, if we find a partial log add it to
    // the global list of logs.  Temporarily turn off the limit on the number
    // of outstanding buffers.
    assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
    size_t old_limit = max_completed_buffers();
    set_max_completed_buffers(MaxCompletedBuffersUnlimited);
  
!   class ConcatenateThreadLogClosure : public ThreadClosure {
!     G1DirtyCardQueueSet* _qset;
!   public:
!     ConcatenateThreadLogClosure(G1DirtyCardQueueSet* qset) : _qset(qset) {}
      virtual void do_thread(Thread* t) {
!       _qset->concatenate_log(G1ThreadLocalData::dirty_card_queue(t));
      }
!   } closure(this);
    Threads::threads_do(&closure);
  
!   concatenate_log(_shared_dirty_card_queue);
    set_max_completed_buffers(old_limit);
  }
--- 210,238 ----
        G1ThreadLocalData::dirty_card_queue(t).reset();
      }
    } closure;
    Threads::threads_do(&closure);
  
!   G1BarrierSet::shared_dirty_card_queue().reset();
  }
  
  void G1DirtyCardQueueSet::concatenate_logs() {
    // Iterate over all the threads, if we find a partial log add it to
    // the global list of logs.  Temporarily turn off the limit on the number
    // of outstanding buffers.
    assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
    size_t old_limit = max_completed_buffers();
    set_max_completed_buffers(MaxCompletedBuffersUnlimited);
  
!   struct ConcatenateThreadLogClosure : public ThreadClosure {
      virtual void do_thread(Thread* t) {
!       G1DirtyCardQueue& dcq = G1ThreadLocalData::dirty_card_queue(t);
!       if (!dcq.is_empty()) {
!         dcq.flush();
        }
!     }
!   } closure;
    Threads::threads_do(&closure);
  
!   G1BarrierSet::shared_dirty_card_queue().flush();
    set_max_completed_buffers(old_limit);
  }