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

rev 47675 : [mq]: 8149127-rename-concurrentrefine-a
rev 47676 : imported patch 8149127-rename-concurrentrefine-b
rev 47677 : [mq]: 8149127-rename-concurrentrefine-b-stefanj-review

*** 27,44 ****
  #include "classfile/stringTable.hpp"
  #include "classfile/symbolTable.hpp"
  #include "code/codeCache.hpp"
  #include "code/icBuffer.hpp"
  #include "gc/g1/bufferingOopClosure.hpp"
- #include "gc/g1/concurrentG1Refine.hpp"
- #include "gc/g1/concurrentG1RefineThread.hpp"
  #include "gc/g1/concurrentMarkThread.inline.hpp"
  #include "gc/g1/g1Allocator.inline.hpp"
  #include "gc/g1/g1CollectedHeap.inline.hpp"
  #include "gc/g1/g1CollectionSet.hpp"
  #include "gc/g1/g1CollectorPolicy.hpp"
  #include "gc/g1/g1CollectorState.hpp"
  #include "gc/g1/g1EvacStats.inline.hpp"
  #include "gc/g1/g1FullGCScope.hpp"
  #include "gc/g1/g1GCPhaseTimes.hpp"
  #include "gc/g1/g1HeapSizingPolicy.hpp"
  #include "gc/g1/g1HeapTransition.hpp"
--- 27,44 ----
  #include "classfile/stringTable.hpp"
  #include "classfile/symbolTable.hpp"
  #include "code/codeCache.hpp"
  #include "code/icBuffer.hpp"
  #include "gc/g1/bufferingOopClosure.hpp"
  #include "gc/g1/concurrentMarkThread.inline.hpp"
  #include "gc/g1/g1Allocator.inline.hpp"
  #include "gc/g1/g1CollectedHeap.inline.hpp"
  #include "gc/g1/g1CollectionSet.hpp"
  #include "gc/g1/g1CollectorPolicy.hpp"
  #include "gc/g1/g1CollectorState.hpp"
+ #include "gc/g1/g1ConcurrentRefine.hpp"
+ #include "gc/g1/g1ConcurrentRefineThread.hpp"
  #include "gc/g1/g1EvacStats.inline.hpp"
  #include "gc/g1/g1FullGCScope.hpp"
  #include "gc/g1/g1GCPhaseTimes.hpp"
  #include "gc/g1/g1HeapSizingPolicy.hpp"
  #include "gc/g1/g1HeapTransition.hpp"
*** 1552,1562 ****
    _ref_processor_cm(NULL),
    _ref_processor_stw(NULL),
    _bot(NULL),
    _hot_card_cache(NULL),
    _g1_rem_set(NULL),
!   _cg1r(NULL),
    _g1mm(NULL),
    _preserved_marks_set(true /* in_c_heap */),
    _secondary_free_list("Secondary Free List", new SecondaryFreeRegionListMtSafeChecker()),
    _old_set("Old Set", false /* humongous */, new OldRegionSetMtSafeChecker()),
    _humongous_set("Master Humongous Set", true /* humongous */, new HumongousRegionSetMtSafeChecker()),
--- 1552,1562 ----
    _ref_processor_cm(NULL),
    _ref_processor_stw(NULL),
    _bot(NULL),
    _hot_card_cache(NULL),
    _g1_rem_set(NULL),
!   _cr(NULL),
    _g1mm(NULL),
    _preserved_marks_set(true /* in_c_heap */),
    _secondary_free_list("Secondary Free List", new SecondaryFreeRegionListMtSafeChecker()),
    _old_set("Old Set", false /* humongous */, new OldRegionSetMtSafeChecker()),
    _humongous_set("Master Humongous Set", true /* humongous */, new HumongousRegionSetMtSafeChecker()),
*** 1631,1641 ****
    return result;
  }
  
  jint G1CollectedHeap::initialize_concurrent_refinement() {
    jint ecode = JNI_OK;
!   _cg1r = ConcurrentG1Refine::create(&ecode);
    return ecode;
  }
  
  jint G1CollectedHeap::initialize() {
    CollectedHeap::pre_initialize();
--- 1631,1641 ----
    return result;
  }
  
  jint G1CollectedHeap::initialize_concurrent_refinement() {
    jint ecode = JNI_OK;
!   _cr = G1ConcurrentRefine::create(&ecode);
    return ecode;
  }
  
  jint G1CollectedHeap::initialize() {
    CollectedHeap::pre_initialize();
*** 1789,1800 ****
      return ecode;
    }
  
    JavaThread::dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon,
                                                  DirtyCardQ_FL_lock,
!                                                 (int)concurrent_g1_refine()->yellow_zone(),
!                                                 (int)concurrent_g1_refine()->red_zone(),
                                                  Shared_DirtyCardQ_lock,
                                                  NULL,  // fl_owner
                                                  true); // init_free_ids
  
    dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon,
--- 1789,1800 ----
      return ecode;
    }
  
    JavaThread::dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon,
                                                  DirtyCardQ_FL_lock,
!                                                 (int)concurrent_refine()->yellow_zone(),
!                                                 (int)concurrent_refine()->red_zone(),
                                                  Shared_DirtyCardQ_lock,
                                                  NULL,  // fl_owner
                                                  true); // init_free_ids
  
    dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon,
*** 1834,1844 ****
  
  void G1CollectedHeap::stop() {
    // Stop all concurrent threads. We do this to make sure these threads
    // do not continue to execute and access resources (e.g. logging)
    // that are destroyed during shutdown.
!   _cg1r->stop();
    _cmThread->stop();
    if (G1StringDedup::is_enabled()) {
      G1StringDedup::stop();
    }
  }
--- 1834,1844 ----
  
  void G1CollectedHeap::stop() {
    // Stop all concurrent threads. We do this to make sure these threads
    // do not continue to execute and access resources (e.g. logging)
    // that are destroyed during shutdown.
!   _cr->stop();
    _cmThread->stop();
    if (G1StringDedup::is_enabled()) {
      G1StringDedup::stop();
    }
  }
*** 2434,2454 ****
  void G1CollectedHeap::print_gc_threads_on(outputStream* st) const {
    workers()->print_worker_threads_on(st);
    _cmThread->print_on(st);
    st->cr();
    _cm->print_worker_threads_on(st);
!   _cg1r->print_worker_threads_on(st); // also prints the sample thread
    if (G1StringDedup::is_enabled()) {
      G1StringDedup::print_worker_threads_on(st);
    }
  }
  
  void G1CollectedHeap::gc_threads_do(ThreadClosure* tc) const {
    workers()->threads_do(tc);
    tc->do_thread(_cmThread);
    _cm->threads_do(tc);
!   _cg1r->threads_do(tc); // also iterates over the sample thread
    if (G1StringDedup::is_enabled()) {
      G1StringDedup::threads_do(tc);
    }
  }
  
--- 2434,2454 ----
  void G1CollectedHeap::print_gc_threads_on(outputStream* st) const {
    workers()->print_worker_threads_on(st);
    _cmThread->print_on(st);
    st->cr();
    _cm->print_worker_threads_on(st);
!   _cr->print_worker_threads_on(st); // also prints the sample thread
    if (G1StringDedup::is_enabled()) {
      G1StringDedup::print_worker_threads_on(st);
    }
  }
  
  void G1CollectedHeap::gc_threads_do(ThreadClosure* tc) const {
    workers()->threads_do(tc);
    tc->do_thread(_cmThread);
    _cm->threads_do(tc);
!   _cr->threads_do(tc); // also iterates over the sample thread
    if (G1StringDedup::is_enabled()) {
      G1StringDedup::threads_do(tc);
    }
  }