C++ G1CollectedHeap类代码示例

 ScanRSClosure(OopsInHeapRegionClosure* oc, int worker_i) :
   _oc(oc),
   _cards(0),
   _cards_done(0),
   _worker_i(worker_i),
   _try_claimed(false)
 {
   _g1h = G1CollectedHeap::heap();
   _bot_shared = _g1h->bot_shared();
   _ct_bs = (CardTableModRefBS*) (_g1h->barrier_set());
   _block_size = MAX2<int>(G1RSetScanBlockSize, 1);
 }

 ScanRSClosure(G1ParPushHeapRSClosure* oc,
               CodeBlobClosure* code_root_cl,
               uint worker_i) :
   _oc(oc),
   _code_root_cl(code_root_cl),
   _strong_code_root_scan_time_sec(0.0),
   _cards(0),
   _cards_done(0),
   _worker_i(worker_i),
   _try_claimed(false)
 {
   _g1h = G1CollectedHeap::heap();
   _bot_shared = _g1h->bot_shared();
   _ct_bs = _g1h->g1_barrier_set();
   _block_size = MAX2<int>(G1RSetScanBlockSize, 1);
 }

 // use_prev_marking == true  -> use "prev" marking information,
 // use_prev_marking == false -> use "next" marking information
 VerifyLiveClosure(G1CollectedHeap* g1h, bool use_prev_marking) :
   _g1h(g1h), _bs(NULL), _containing_obj(NULL),
   _failures(false), _n_failures(0), _use_prev_marking(use_prev_marking)
 {
   BarrierSet* bs = _g1h->barrier_set();
   if (bs->is_a(BarrierSet::CardTableModRef))
     _bs = (CardTableModRefBS*)bs;
 }

 // _vo == UsePrevMarking -> use "prev" marking information,
 // _vo == UseNextMarking -> use "next" marking information,
 // _vo == UseMarkWord    -> use mark word from object header.
 VerifyLiveClosure(G1CollectedHeap* g1h, VerifyOption vo) :
   _g1h(g1h), _bs(NULL), _containing_obj(NULL),
   _failures(false), _n_failures(0), _vo(vo)
 {
   BarrierSet* bs = _g1h->barrier_set();
   if (bs->is_a(BarrierSet::CardTableModRef))
     _bs = (CardTableModRefBS*)bs;
 }

 ScrubRSClosure(BitMap* region_bm, BitMap* card_bm) :
   _g1h(G1CollectedHeap::heap()),
   _region_bm(region_bm), _card_bm(card_bm),
   _ctbs(NULL)
 {
   ModRefBarrierSet* bs = _g1h->mr_bs();
   guarantee(bs->is_a(BarrierSet::CardTableModRef), "Precondition");
   _ctbs = (CardTableModRefBS*)bs;
 }

 ScrubRSClosure(BitMap* region_bm, BitMap* card_bm) :
   _g1h(G1CollectedHeap::heap()),
   _region_bm(region_bm), _card_bm(card_bm),
   _ctbs(_g1h->g1_barrier_set()) {}

 UpdateRSetDeferred(G1CollectedHeap* g1, DirtyCardQueue* dcq) :
   _g1(g1), _ct_bs(_g1->g1_barrier_set()), _dcq(dcq) {}

 RemoveSelfForwardPtrHRClosure(G1CollectedHeap* g1h,
                               uint worker_id) :
   _g1h(g1h), _dcq(&g1h->dirty_card_queue_set()), _update_rset_cl(g1h, &_dcq),
   _worker_id(worker_id), _cm(_g1h->concurrent_mark()) {
   }

 G1PrepareCompactClosure() :
   _g1h(G1CollectedHeap::heap()),
   _mrbs(_g1h->g1_barrier_set()),
   _humongous_regions_removed() { }

 G1PrepareCompactClosure(CompactibleSpace* cs)
 : _g1h(G1CollectedHeap::heap()),
   _mrbs(_g1h->g1_barrier_set()),
   _cp(NULL, cs, cs->initialize_threshold()),
   _humongous_proxy_set("G1MarkSweep Humongous Proxy Set") { }

 void do_oop_work(T* p) {
   _work->do_oop(p);
   T oop_or_narrowoop = oopDesc::load_heap_oop(p);
   if (!oopDesc::is_null(oop_or_narrowoop)) {
     oop o = oopDesc::decode_heap_oop_not_null(oop_or_narrowoop);
     HeapRegion* hr = _g1h->heap_region_containing_raw(o);
     assert(!_g1h->obj_in_cs(o) || hr->rem_set()->strong_code_roots_list_contains(_nm), "if o still in CS then evacuation failed and nm must already be in the remset");
     hr->add_strong_code_root(_nm);
   }
 }

  bool doHeapRegion(HeapRegion* r) {
    assert(r->in_collection_set(), "should only be called on elements of CS.");
    HeapRegionRemSet* hrrs = r->rem_set();
    if (hrrs->iter_is_complete()) return false; // All done.
    if (!_try_claimed && !hrrs->claim_iter()) return false;
    // If we ever free the collection set concurrently, we should also
    // clear the card table concurrently therefore we won't need to
    // add regions of the collection set to the dirty cards region.
    _g1h->push_dirty_cards_region(r);
    // If we didn't return above, then
    //   _try_claimed || r->claim_iter()
    // is true: either we're supposed to work on claimed-but-not-complete
    // regions, or we successfully claimed the region.

    HeapRegionRemSetIterator iter(hrrs);
    size_t card_index;

    // We claim cards in block so as to reduce the contention. The block size is determined by
    // the G1RSetScanBlockSize parameter.
    size_t jump_to_card = hrrs->iter_claimed_next(_block_size);
    for (size_t current_card = 0; iter.has_next(card_index); current_card++) {
      if (current_card >= jump_to_card + _block_size) {
        jump_to_card = hrrs->iter_claimed_next(_block_size);
      }
      if (current_card < jump_to_card) continue;
      HeapWord* card_start = _g1h->bot_shared()->address_for_index(card_index);
#if 0
      gclog_or_tty->print("Rem set iteration yielded card [" PTR_FORMAT ", " PTR_FORMAT ").\n",
                          card_start, card_start + CardTableModRefBS::card_size_in_words);
#endif

      HeapRegion* card_region = _g1h->heap_region_containing(card_start);
      _cards++;

      if (!card_region->is_on_dirty_cards_region_list()) {
        _g1h->push_dirty_cards_region(card_region);
      }

      // If the card is dirty, then we will scan it during updateRS.
      if (!card_region->in_collection_set() &&
          !_ct_bs->is_card_dirty(card_index)) {
        scanCard(card_index, card_region);
      }
    }
    if (!_try_claimed) {
      // Scan the strong code root list attached to the current region
      scan_strong_code_roots(r);

      hrrs->set_iter_complete();
    }
    return false;
  }

  bool doHeapRegion(HeapRegion* r) {
    assert(r->in_collection_set(), "should only be called on elements of CS.");
    HeapRegionRemSet* hrrs = r->rem_set();
    if (hrrs->iter_is_complete()) return false; // All done.
    if (!_try_claimed && !hrrs->claim_iter()) return false;
    _g1h->push_dirty_cards_region(r);
    // If we didn't return above, then
    //   _try_claimed || r->claim_iter()
    // is true: either we're supposed to work on claimed-but-not-complete
    // regions, or we successfully claimed the region.
    HeapRegionRemSetIterator* iter = _g1h->rem_set_iterator(_worker_i);
    hrrs->init_iterator(iter);
    size_t card_index;

    // We claim cards in block so as to recude the contention. The block size is determined by
    // the G1RSetScanBlockSize parameter.
    size_t jump_to_card = hrrs->iter_claimed_next(_block_size);
    for (size_t current_card = 0; iter->has_next(card_index); current_card++) {
      if (current_card >= jump_to_card + _block_size) {
        jump_to_card = hrrs->iter_claimed_next(_block_size);
      }
      if (current_card < jump_to_card) continue;
      HeapWord* card_start = _g1h->bot_shared()->address_for_index(card_index);
#if 0
      gclog_or_tty->print("Rem set iteration yielded card [" PTR_FORMAT ", " PTR_FORMAT ").\n",
                          card_start, card_start + CardTableModRefBS::card_size_in_words);
#endif

      HeapRegion* card_region = _g1h->heap_region_containing(card_start);
      assert(card_region != NULL, "Yielding cards not in the heap?");
      _cards++;

      if (!card_region->is_on_dirty_cards_region_list()) {
        _g1h->push_dirty_cards_region(card_region);
      }

       // If the card is dirty, then we will scan it during updateRS.
      if (!card_region->in_collection_set() && !_ct_bs->is_card_dirty(card_index)) {
        // We make the card as "claimed" lazily (so races are possible but they're benign),
        // which reduces the number of duplicate scans (the rsets of the regions in the cset
        // can intersect).
        if (!_ct_bs->is_card_claimed(card_index)) {
          _ct_bs->set_card_claimed(card_index);
          scanCard(card_index, card_region);
        }
      }
    }
    if (!_try_claimed) {
      hrrs->set_iter_complete();
    }
    return false;
  }

 template <class T> void do_oop_work(T* p) {
   oop obj = oopDesc::load_decode_heap_oop(p);
   if (_g1->obj_in_cs(obj)) {
     size_t card_index = _ct_bs->index_for(p);
     if (_ct_bs->mark_card_deferred(card_index)) {
       _dcq->enqueue((jbyte*)_ct_bs->byte_for_index(card_index));
     }
   }
 }

 void update_sets() {
     // We'll recalculate total used bytes and recreate the free list
     // at the end of the GC, so no point in updating those values here.
     _g1h->update_sets_after_freeing_regions(0, /* pre_used */
                                             NULL, /* free_list */
                                             NULL, /* old_proxy_set */
                                             &_humongous_proxy_set,
                                             false /* par */);
 }