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

rev 53582 : imported patch rename

*** 35,44 ****
--- 35,45 ----
  #include "gc/g1/g1CollectorPolicy.hpp"
  #include "gc/g1/g1CollectorState.hpp"
  #include "gc/g1/g1ConcurrentRefine.hpp"
  #include "gc/g1/g1ConcurrentRefineThread.hpp"
  #include "gc/g1/g1ConcurrentMarkThread.inline.hpp"
+ #include "gc/g1/g1DirtyCardQueue.hpp"
  #include "gc/g1/g1EvacStats.inline.hpp"
  #include "gc/g1/g1FullCollector.hpp"
  #include "gc/g1/g1GCPhaseTimes.hpp"
  #include "gc/g1/g1HeapSizingPolicy.hpp"
  #include "gc/g1/g1HeapTransition.hpp"
*** 105,115 ****
  // and allocate_new_tlab, which are the "entry" points to the
  // allocation code from the rest of the JVM.  (Note that this does not
  // apply to TLAB allocation, which is not part of this interface: it
  // is done by clients of this interface.)
  
! class RedirtyLoggedCardTableEntryClosure : public CardTableEntryClosure {
   private:
    size_t _num_dirtied;
    G1CollectedHeap* _g1h;
    G1CardTable* _g1_ct;
  
--- 106,116 ----
  // and allocate_new_tlab, which are the "entry" points to the
  // allocation code from the rest of the JVM.  (Note that this does not
  // apply to TLAB allocation, which is not part of this interface: it
  // is done by clients of this interface.)
  
! class RedirtyLoggedCardTableEntryClosure : public G1CardTableEntryClosure {
   private:
    size_t _num_dirtied;
    G1CollectedHeap* _g1h;
    G1CardTable* _g1_ct;
  
*** 122,132 ****
      // collection set and has not had an evacuation failure.
      return _g1h->is_in_cset(hr) && !hr->evacuation_failed();
    }
  
   public:
!   RedirtyLoggedCardTableEntryClosure(G1CollectedHeap* g1h) : CardTableEntryClosure(),
      _num_dirtied(0), _g1h(g1h), _g1_ct(g1h->card_table()) { }
  
    bool do_card_ptr(jbyte* card_ptr, uint worker_i) {
      HeapRegion* hr = region_for_card(card_ptr);
  
--- 123,133 ----
      // collection set and has not had an evacuation failure.
      return _g1h->is_in_cset(hr) && !hr->evacuation_failed();
    }
  
   public:
!   RedirtyLoggedCardTableEntryClosure(G1CollectedHeap* g1h) : G1CardTableEntryClosure(),
      _num_dirtied(0), _g1h(g1h), _g1_ct(g1h->card_table()) { }
  
    bool do_card_ptr(jbyte* card_ptr, uint worker_i) {
      HeapRegion* hr = region_for_card(card_ptr);
  
*** 1809,1819 ****
    if (ecode != JNI_OK) {
      return ecode;
    }
  
    {
!     DirtyCardQueueSet& dcqs = G1BarrierSet::dirty_card_queue_set();
      dcqs.set_process_completed_buffers_threshold(concurrent_refine()->yellow_zone());
      dcqs.set_max_completed_buffers(concurrent_refine()->red_zone());
    }
  
    // Here we allocate the dummy HeapRegion that is required by the
--- 1810,1820 ----
    if (ecode != JNI_OK) {
      return ecode;
    }
  
    {
!     G1DirtyCardQueueSet& dcqs = G1BarrierSet::dirty_card_queue_set();
      dcqs.set_process_completed_buffers_threshold(concurrent_refine()->yellow_zone());
      dcqs.set_max_completed_buffers(concurrent_refine()->red_zone());
    }
  
    // Here we allocate the dummy HeapRegion that is required by the
*** 1952,1967 ****
  
  size_t G1CollectedHeap::unused_committed_regions_in_bytes() const {
    return _hrm->total_free_bytes();
  }
  
! void G1CollectedHeap::iterate_hcc_closure(CardTableEntryClosure* cl, uint worker_i) {
    _hot_card_cache->drain(cl, worker_i);
  }
  
! void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl, uint worker_i) {
!   DirtyCardQueueSet& dcqs = G1BarrierSet::dirty_card_queue_set();
    size_t n_completed_buffers = 0;
    while (dcqs.apply_closure_during_gc(cl, worker_i)) {
      n_completed_buffers++;
    }
    assert(dcqs.completed_buffers_num() == 0, "Completed buffers exist!");
--- 1953,1968 ----
  
  size_t G1CollectedHeap::unused_committed_regions_in_bytes() const {
    return _hrm->total_free_bytes();
  }
  
! void G1CollectedHeap::iterate_hcc_closure(G1CardTableEntryClosure* cl, uint worker_i) {
    _hot_card_cache->drain(cl, worker_i);
  }
  
! void G1CollectedHeap::iterate_dirty_card_closure(G1CardTableEntryClosure* cl, uint worker_i) {
!   G1DirtyCardQueueSet& dcqs = G1BarrierSet::dirty_card_queue_set();
    size_t n_completed_buffers = 0;
    while (dcqs.apply_closure_during_gc(cl, worker_i)) {
      n_completed_buffers++;
    }
    assert(dcqs.completed_buffers_num() == 0, "Completed buffers exist!");
*** 2607,2620 ****
  }
  
  size_t G1CollectedHeap::pending_card_num() {
    size_t extra_cards = 0;
    for (JavaThreadIteratorWithHandle jtiwh; JavaThread *curr = jtiwh.next(); ) {
!     DirtyCardQueue& dcq = G1ThreadLocalData::dirty_card_queue(curr);
      extra_cards += dcq.size();
    }
!   DirtyCardQueueSet& dcqs = G1BarrierSet::dirty_card_queue_set();
    size_t buffer_size = dcqs.buffer_size();
    size_t buffer_num = dcqs.completed_buffers_num();
  
    return buffer_size * buffer_num + extra_cards;
  }
--- 2608,2621 ----
  }
  
  size_t G1CollectedHeap::pending_card_num() {
    size_t extra_cards = 0;
    for (JavaThreadIteratorWithHandle jtiwh; JavaThread *curr = jtiwh.next(); ) {
!     G1DirtyCardQueue& dcq = G1ThreadLocalData::dirty_card_queue(curr);
      extra_cards += dcq.size();
    }
!   G1DirtyCardQueueSet& dcqs = G1BarrierSet::dirty_card_queue_set();
    size_t buffer_size = dcqs.buffer_size();
    size_t buffer_num = dcqs.completed_buffers_num();
  
    return buffer_size * buffer_num + extra_cards;
  }
*** 2632,2642 ****
  class RegisterHumongousWithInCSetFastTestClosure : public HeapRegionClosure {
   private:
    size_t _total_humongous;
    size_t _candidate_humongous;
  
!   DirtyCardQueue _dcq;
  
    bool humongous_region_is_candidate(G1CollectedHeap* g1h, HeapRegion* region) const {
      assert(region->is_starts_humongous(), "Must start a humongous object");
  
      oop obj = oop(region->bottom());
--- 2633,2643 ----
  class RegisterHumongousWithInCSetFastTestClosure : public HeapRegionClosure {
   private:
    size_t _total_humongous;
    size_t _candidate_humongous;
  
!   G1DirtyCardQueue _dcq;
  
    bool humongous_region_is_candidate(G1CollectedHeap* g1h, HeapRegion* region) const {
      assert(region->is_starts_humongous(), "Must start a humongous object");
  
      oop obj = oop(region->bottom());
*** 3412,3425 ****
    workers()->run_task(&cl);
  }
  
  class G1RedirtyLoggedCardsTask : public AbstractGangTask {
   private:
!   DirtyCardQueueSet* _queue;
    G1CollectedHeap* _g1h;
   public:
!   G1RedirtyLoggedCardsTask(DirtyCardQueueSet* queue, G1CollectedHeap* g1h) : AbstractGangTask("Redirty Cards"),
      _queue(queue), _g1h(g1h) { }
  
    virtual void work(uint worker_id) {
      G1GCPhaseTimes* phase_times = _g1h->g1_policy()->phase_times();
      G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::RedirtyCards, worker_id);
--- 3413,3426 ----
    workers()->run_task(&cl);
  }
  
  class G1RedirtyLoggedCardsTask : public AbstractGangTask {
   private:
!   G1DirtyCardQueueSet* _queue;
    G1CollectedHeap* _g1h;
   public:
!   G1RedirtyLoggedCardsTask(G1DirtyCardQueueSet* queue, G1CollectedHeap* g1h) : AbstractGangTask("Redirty Cards"),
      _queue(queue), _g1h(g1h) { }
  
    virtual void work(uint worker_id) {
      G1GCPhaseTimes* phase_times = _g1h->g1_policy()->phase_times();
      G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::RedirtyCards, worker_id);
*** 3436,3446 ****
  
    G1RedirtyLoggedCardsTask redirty_task(&dirty_card_queue_set(), this);
    dirty_card_queue_set().reset_for_par_iteration();
    workers()->run_task(&redirty_task);
  
!   DirtyCardQueueSet& dcq = G1BarrierSet::dirty_card_queue_set();
    dcq.merge_bufferlists(&dirty_card_queue_set());
    assert(dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed");
  
    g1_policy()->phase_times()->record_redirty_logged_cards_time_ms((os::elapsedTime() - redirty_logged_cards_start) * 1000.0);
  }
--- 3437,3447 ----
  
    G1RedirtyLoggedCardsTask redirty_task(&dirty_card_queue_set(), this);
    dirty_card_queue_set().reset_for_par_iteration();
    workers()->run_task(&redirty_task);
  
!   G1DirtyCardQueueSet& dcq = G1BarrierSet::dirty_card_queue_set();
    dcq.merge_bufferlists(&dirty_card_queue_set());
    assert(dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed");
  
    g1_policy()->phase_times()->record_redirty_logged_cards_time_ms((os::elapsedTime() - redirty_logged_cards_start) * 1000.0);
  }