src/hotspot/share/gc/g1/g1CollectedHeap.cpp
changeset 49751 c3a10df652c0
parent 49743 b2da6c360225
child 49752 93d84f667d12
equal deleted inserted replaced
49750:bdcfe8154201 49751:c3a10df652c0
    28 #include "classfile/symbolTable.hpp"
    28 #include "classfile/symbolTable.hpp"
    29 #include "code/codeCache.hpp"
    29 #include "code/codeCache.hpp"
    30 #include "code/icBuffer.hpp"
    30 #include "code/icBuffer.hpp"
    31 #include "gc/g1/bufferingOopClosure.hpp"
    31 #include "gc/g1/bufferingOopClosure.hpp"
    32 #include "gc/g1/g1Allocator.inline.hpp"
    32 #include "gc/g1/g1Allocator.inline.hpp"
       
    33 #include "gc/g1/g1BarrierSet.hpp"
    33 #include "gc/g1/g1CollectedHeap.inline.hpp"
    34 #include "gc/g1/g1CollectedHeap.inline.hpp"
    34 #include "gc/g1/g1CollectionSet.hpp"
    35 #include "gc/g1/g1CollectionSet.hpp"
    35 #include "gc/g1/g1CollectorPolicy.hpp"
    36 #include "gc/g1/g1CollectorPolicy.hpp"
    36 #include "gc/g1/g1CollectorState.hpp"
    37 #include "gc/g1/g1CollectorState.hpp"
    37 #include "gc/g1/g1ConcurrentRefine.hpp"
    38 #include "gc/g1/g1ConcurrentRefine.hpp"
  1034   if (_hot_card_cache->use_cache()) {
  1035   if (_hot_card_cache->use_cache()) {
  1035     _hot_card_cache->reset_hot_cache();
  1036     _hot_card_cache->reset_hot_cache();
  1036   }
  1037   }
  1037 
  1038 
  1038   // Discard all remembered set updates.
  1039   // Discard all remembered set updates.
  1039   JavaThread::dirty_card_queue_set().abandon_logs();
  1040   G1BarrierSet::dirty_card_queue_set().abandon_logs();
  1040   assert(dirty_card_queue_set().completed_buffers_num() == 0, "DCQS should be empty");
  1041   assert(dirty_card_queue_set().completed_buffers_num() == 0, "DCQS should be empty");
  1041 }
  1042 }
  1042 
  1043 
  1043 void G1CollectedHeap::verify_after_full_collection() {
  1044 void G1CollectedHeap::verify_after_full_collection() {
  1044   _hrm.verify_optional();
  1045   _hrm.verify_optional();
  1634   }
  1635   }
  1635 
  1636 
  1636   // Perform any initialization actions delegated to the policy.
  1637   // Perform any initialization actions delegated to the policy.
  1637   g1_policy()->init(this, &_collection_set);
  1638   g1_policy()->init(this, &_collection_set);
  1638 
  1639 
  1639   JavaThread::satb_mark_queue_set().initialize(SATB_Q_CBL_mon,
  1640   G1BarrierSet::satb_mark_queue_set().initialize(SATB_Q_CBL_mon,
  1640                                                SATB_Q_FL_lock,
  1641                                                  SATB_Q_FL_lock,
  1641                                                G1SATBProcessCompletedThreshold,
  1642                                                  G1SATBProcessCompletedThreshold,
  1642                                                Shared_SATB_Q_lock);
  1643                                                  Shared_SATB_Q_lock);
  1643 
  1644 
  1644   jint ecode = initialize_concurrent_refinement();
  1645   jint ecode = initialize_concurrent_refinement();
  1645   if (ecode != JNI_OK) {
  1646   if (ecode != JNI_OK) {
  1646     return ecode;
  1647     return ecode;
  1647   }
  1648   }
  1649   ecode = initialize_young_gen_sampling_thread();
  1650   ecode = initialize_young_gen_sampling_thread();
  1650   if (ecode != JNI_OK) {
  1651   if (ecode != JNI_OK) {
  1651     return ecode;
  1652     return ecode;
  1652   }
  1653   }
  1653 
  1654 
  1654   JavaThread::dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon,
  1655   G1BarrierSet::dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon,
  1655                                                 DirtyCardQ_FL_lock,
  1656                                                   DirtyCardQ_FL_lock,
  1656                                                 (int)concurrent_refine()->yellow_zone(),
  1657                                                   (int)concurrent_refine()->yellow_zone(),
  1657                                                 (int)concurrent_refine()->red_zone(),
  1658                                                   (int)concurrent_refine()->red_zone(),
  1658                                                 Shared_DirtyCardQ_lock,
  1659                                                   Shared_DirtyCardQ_lock,
  1659                                                 NULL,  // fl_owner
  1660                                                   NULL,  // fl_owner
  1660                                                 true); // init_free_ids
  1661                                                   true); // init_free_ids
  1661 
  1662 
  1662   dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon,
  1663   dirty_card_queue_set().initialize(DirtyCardQ_CBL_mon,
  1663                                     DirtyCardQ_FL_lock,
  1664                                     DirtyCardQ_FL_lock,
  1664                                     -1, // never trigger processing
  1665                                     -1, // never trigger processing
  1665                                     -1, // no limit on length
  1666                                     -1, // no limit on length
  1666                                     Shared_DirtyCardQ_lock,
  1667                                     Shared_DirtyCardQ_lock,
  1667                                     &JavaThread::dirty_card_queue_set());
  1668                                     &G1BarrierSet::dirty_card_queue_set());
  1668 
  1669 
  1669   // Here we allocate the dummy HeapRegion that is required by the
  1670   // Here we allocate the dummy HeapRegion that is required by the
  1670   // G1AllocRegion class.
  1671   // G1AllocRegion class.
  1671   HeapRegion* dummy_region = _hrm.get_dummy_region();
  1672   HeapRegion* dummy_region = _hrm.get_dummy_region();
  1672 
  1673 
  1831 void G1CollectedHeap::iterate_hcc_closure(CardTableEntryClosure* cl, uint worker_i) {
  1832 void G1CollectedHeap::iterate_hcc_closure(CardTableEntryClosure* cl, uint worker_i) {
  1832   _hot_card_cache->drain(cl, worker_i);
  1833   _hot_card_cache->drain(cl, worker_i);
  1833 }
  1834 }
  1834 
  1835 
  1835 void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl, uint worker_i) {
  1836 void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl, uint worker_i) {
  1836   DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
  1837   DirtyCardQueueSet& dcqs = G1BarrierSet::dirty_card_queue_set();
  1837   size_t n_completed_buffers = 0;
  1838   size_t n_completed_buffers = 0;
  1838   while (dcqs.apply_closure_during_gc(cl, worker_i)) {
  1839   while (dcqs.apply_closure_during_gc(cl, worker_i)) {
  1839     n_completed_buffers++;
  1840     n_completed_buffers++;
  1840   }
  1841   }
  1841   g1_policy()->phase_times()->record_thread_work_item(G1GCPhaseTimes::UpdateRS, worker_i, n_completed_buffers);
  1842   g1_policy()->phase_times()->record_thread_work_item(G1GCPhaseTimes::UpdateRS, worker_i, n_completed_buffers);
  2465   size_t extra_cards = 0;
  2466   size_t extra_cards = 0;
  2466   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *curr = jtiwh.next(); ) {
  2467   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *curr = jtiwh.next(); ) {
  2467     DirtyCardQueue& dcq = curr->dirty_card_queue();
  2468     DirtyCardQueue& dcq = curr->dirty_card_queue();
  2468     extra_cards += dcq.size();
  2469     extra_cards += dcq.size();
  2469   }
  2470   }
  2470   DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
  2471   DirtyCardQueueSet& dcqs = G1BarrierSet::dirty_card_queue_set();
  2471   size_t buffer_size = dcqs.buffer_size();
  2472   size_t buffer_size = dcqs.buffer_size();
  2472   size_t buffer_num = dcqs.completed_buffers_num();
  2473   size_t buffer_num = dcqs.completed_buffers_num();
  2473 
  2474 
  2474   return buffer_size * buffer_num + extra_cards;
  2475   return buffer_size * buffer_num + extra_cards;
  2475 }
  2476 }
  2549 
  2550 
  2550  public:
  2551  public:
  2551   RegisterHumongousWithInCSetFastTestClosure()
  2552   RegisterHumongousWithInCSetFastTestClosure()
  2552   : _total_humongous(0),
  2553   : _total_humongous(0),
  2553     _candidate_humongous(0),
  2554     _candidate_humongous(0),
  2554     _dcq(&JavaThread::dirty_card_queue_set()) {
  2555     _dcq(&G1BarrierSet::dirty_card_queue_set()) {
  2555   }
  2556   }
  2556 
  2557 
  2557   virtual bool do_heap_region(HeapRegion* r) {
  2558   virtual bool do_heap_region(HeapRegion* r) {
  2558     if (!r->is_starts_humongous()) {
  2559     if (!r->is_starts_humongous()) {
  2559       return false;
  2560       return false;
  3621 
  3622 
  3622   G1RedirtyLoggedCardsTask redirty_task(&dirty_card_queue_set(), this);
  3623   G1RedirtyLoggedCardsTask redirty_task(&dirty_card_queue_set(), this);
  3623   dirty_card_queue_set().reset_for_par_iteration();
  3624   dirty_card_queue_set().reset_for_par_iteration();
  3624   workers()->run_task(&redirty_task);
  3625   workers()->run_task(&redirty_task);
  3625 
  3626 
  3626   DirtyCardQueueSet& dcq = JavaThread::dirty_card_queue_set();
  3627   DirtyCardQueueSet& dcq = G1BarrierSet::dirty_card_queue_set();
  3627   dcq.merge_bufferlists(&dirty_card_queue_set());
  3628   dcq.merge_bufferlists(&dirty_card_queue_set());
  3628   assert(dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed");
  3629   assert(dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed");
  3629 
  3630 
  3630   g1_policy()->phase_times()->record_redirty_logged_cards_time_ms((os::elapsedTime() - redirty_logged_cards_start) * 1000.0);
  3631   g1_policy()->phase_times()->record_redirty_logged_cards_time_ms((os::elapsedTime() - redirty_logged_cards_start) * 1000.0);
  3631 }
  3632 }