src/share/vm/gc/g1/g1RemSet.cpp

*** 43,61 ****
  G1RemSet::G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs)
    : _g1(g1), _conc_refine_cards(0),
      _ct_bs(ct_bs), _g1p(_g1->g1_policy()),
      _cg1r(g1->concurrent_g1_refine()),
      _cset_rs_update_cl(NULL),
!     _prev_period_summary()
  {
    _cset_rs_update_cl = NEW_C_HEAP_ARRAY(G1ParPushHeapRSClosure*, n_workers(), mtGC);
    for (uint i = 0; i < n_workers(); i++) {
      _cset_rs_update_cl[i] = NULL;
    }
    if (G1SummarizeRSetStats) {
      _prev_period_summary.initialize(this);
    }
  }
  
  G1RemSet::~G1RemSet() {
    for (uint i = 0; i < n_workers(); i++) {
      assert(_cset_rs_update_cl[i] == NULL, "it should be");
--- 43,71 ----
  G1RemSet::G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs)
    : _g1(g1), _conc_refine_cards(0),
      _ct_bs(ct_bs), _g1p(_g1->g1_policy()),
      _cg1r(g1->concurrent_g1_refine()),
      _cset_rs_update_cl(NULL),
!     _prev_period_summary(),
!     _into_cset_dirty_card_queue_set(false)
  {
    _cset_rs_update_cl = NEW_C_HEAP_ARRAY(G1ParPushHeapRSClosure*, n_workers(), mtGC);
    for (uint i = 0; i < n_workers(); i++) {
      _cset_rs_update_cl[i] = NULL;
    }
    if (G1SummarizeRSetStats) {
      _prev_period_summary.initialize(this);
    }
+   // Initialize the card queue set used to hold cards containing
+   // references into the collection set.
+   _into_cset_dirty_card_queue_set.initialize(NULL, // Should never be called by the Java code
+                                              DirtyCardQ_CBL_mon,
+                                              DirtyCardQ_FL_lock,
+                                              -1, // never trigger processing
+                                              -1, // no limit on length
+                                              Shared_DirtyCardQ_lock,
+                                              &JavaThread::dirty_card_queue_set());
  }
  
  G1RemSet::~G1RemSet() {
    for (uint i = 0; i < n_workers(); i++) {
      assert(_cset_rs_update_cl[i] == NULL, "it should be");
*** 240,250 ****
      assert(worker_i < ParallelGCThreads, "should be a GC worker");
  
      if (_g1rs->refine_card(card_ptr, worker_i, true)) {
        // 'card_ptr' contains references that point into the collection
        // set. We need to record the card in the DCQS
!       // (G1CollectedHeap::into_cset_dirty_card_queue_set())
        // that's used for that purpose.
        //
        // Enqueue the card
        _into_cset_dcq->enqueue(card_ptr);
      }
--- 250,260 ----
      assert(worker_i < ParallelGCThreads, "should be a GC worker");
  
      if (_g1rs->refine_card(card_ptr, worker_i, true)) {
        // 'card_ptr' contains references that point into the collection
        // set. We need to record the card in the DCQS
!       // (_into_cset_dirty_card_queue_set)
        // that's used for that purpose.
        //
        // Enqueue the card
        _into_cset_dcq->enqueue(card_ptr);
      }
*** 284,294 ****
    // are just discarded (there's no need to update the RSets of regions
    // that were in the collection set - after the pause these regions
    // are wholly 'free' of live objects. In the event of an evacuation
    // failure the cards/buffers in this queue set are passed to the
    // DirtyCardQueueSet that is used to manage RSet updates
!   DirtyCardQueue into_cset_dcq(&_g1->into_cset_dirty_card_queue_set());
  
    updateRS(&into_cset_dcq, worker_i);
    size_t cards_scanned = scanRS(oc, heap_region_codeblobs, worker_i);
  
    // We now clear the cached values of _cset_rs_update_cl for this worker
--- 294,304 ----
    // are just discarded (there's no need to update the RSets of regions
    // that were in the collection set - after the pause these regions
    // are wholly 'free' of live objects. In the event of an evacuation
    // failure the cards/buffers in this queue set are passed to the
    // DirtyCardQueueSet that is used to manage RSet updates
!   DirtyCardQueue into_cset_dcq(&_into_cset_dirty_card_queue_set);
  
    updateRS(&into_cset_dcq, worker_i);
    size_t cards_scanned = scanRS(oc, heap_region_codeblobs, worker_i);
  
    // We now clear the cached values of _cset_rs_update_cl for this worker
*** 307,317 ****
    // Cleanup after copy
    _g1->set_refine_cte_cl_concurrency(true);
    // Set all cards back to clean.
    _g1->cleanUpCardTable();
  
!   DirtyCardQueueSet& into_cset_dcqs = _g1->into_cset_dirty_card_queue_set();
    int into_cset_n_buffers = into_cset_dcqs.completed_buffers_num();
  
    if (_g1->evacuation_failed()) {
      double restore_remembered_set_start = os::elapsedTime();
  
--- 317,327 ----
    // Cleanup after copy
    _g1->set_refine_cte_cl_concurrency(true);
    // Set all cards back to clean.
    _g1->cleanUpCardTable();
  
!   DirtyCardQueueSet& into_cset_dcqs = _into_cset_dirty_card_queue_set;
    int into_cset_n_buffers = into_cset_dcqs.completed_buffers_num();
  
    if (_g1->evacuation_failed()) {
      double restore_remembered_set_start = os::elapsedTime();
  
*** 323,336 ****
      _g1->g1_policy()->phase_times()->record_evac_fail_restore_remsets((os::elapsedTime() - restore_remembered_set_start) * 1000.0);
    }
  
    // Free any completed buffers in the DirtyCardQueueSet used to hold cards
    // which contain references that point into the collection.
!   _g1->into_cset_dirty_card_queue_set().clear();
!   assert(_g1->into_cset_dirty_card_queue_set().completed_buffers_num() == 0,
           "all buffers should be freed");
!   _g1->into_cset_dirty_card_queue_set().clear_n_completed_buffers();
  }
  
  class ScrubRSClosure: public HeapRegionClosure {
    G1CollectedHeap* _g1h;
    BitMap* _region_bm;
--- 333,346 ----
      _g1->g1_policy()->phase_times()->record_evac_fail_restore_remsets((os::elapsedTime() - restore_remembered_set_start) * 1000.0);
    }
  
    // Free any completed buffers in the DirtyCardQueueSet used to hold cards
    // which contain references that point into the collection.
!   _into_cset_dirty_card_queue_set.clear();
!   assert(_into_cset_dirty_card_queue_set.completed_buffers_num() == 0,
           "all buffers should be freed");
!   _into_cset_dirty_card_queue_set.clear_n_completed_buffers();
  }
  
  class ScrubRSClosure: public HeapRegionClosure {
    G1CollectedHeap* _g1h;
    BitMap* _region_bm;
*** 584,596 ****
  
      G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache();
      bool use_hot_card_cache = hot_card_cache->use_cache();
      hot_card_cache->set_use_cache(false);
  
!     DirtyCardQueue into_cset_dcq(&_g1->into_cset_dirty_card_queue_set());
      updateRS(&into_cset_dcq, 0);
!     _g1->into_cset_dirty_card_queue_set().clear();
  
      hot_card_cache->set_use_cache(use_hot_card_cache);
      assert(JavaThread::dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed");
    }
  }
--- 594,606 ----
  
      G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache();
      bool use_hot_card_cache = hot_card_cache->use_cache();
      hot_card_cache->set_use_cache(false);
  
!     DirtyCardQueue into_cset_dcq(&_into_cset_dirty_card_queue_set);
      updateRS(&into_cset_dcq, 0);
!     _into_cset_dirty_card_queue_set.clear();
  
      hot_card_cache->set_use_cache(use_hot_card_cache);
      assert(JavaThread::dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed");
    }
  }