< prev index next >
src/share/vm/gc/g1/g1CollectedHeap.cpp
Print this page
rev 12906 : [mq]: gc_interface
@@ -120,32 +120,32 @@
class RedirtyLoggedCardTableEntryClosure : public CardTableEntryClosure {
private:
size_t _num_dirtied;
G1CollectedHeap* _g1h;
- G1SATBCardTableLoggingModRefBS* _g1_bs;
+ G1CardTable* _g1_ct;
HeapRegion* region_for_card(jbyte* card_ptr) const {
- return _g1h->heap_region_containing(_g1_bs->addr_for(card_ptr));
+ return _g1h->heap_region_containing(_g1_ct->addr_for(card_ptr));
}
bool will_become_free(HeapRegion* hr) const {
// A region will be freed by free_collection_set if the region is in the
// 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_bs(g1h->g1_barrier_set()) { }
+ _num_dirtied(0), _g1h(g1h), _g1_ct(g1h->g1_card_table()) { }
bool do_card_ptr(jbyte* card_ptr, uint worker_i) {
HeapRegion* hr = region_for_card(card_ptr);
// Should only dirty cards in regions that won't be freed.
if (!will_become_free(hr)) {
- *card_ptr = CardTableModRefBS::dirty_card_val();
+ *card_ptr = G1CardTable::dirty_card_val();
_num_dirtied++;
}
return true;
}
@@ -1074,14 +1074,14 @@
ShouldNotReachHere();
}
class PostMCRemSetClearClosure: public HeapRegionClosure {
G1CollectedHeap* _g1h;
- ModRefBarrierSet* _mr_bs;
+ G1CardTable* _ct;
public:
- PostMCRemSetClearClosure(G1CollectedHeap* g1h, ModRefBarrierSet* mr_bs) :
- _g1h(g1h), _mr_bs(mr_bs) {}
+ PostMCRemSetClearClosure(G1CollectedHeap* g1h, G1CardTable* ct) :
+ _g1h(g1h), _ct(ct) {}
bool doHeapRegion(HeapRegion* r) {
HeapRegionRemSet* hrrs = r->rem_set();
_g1h->reset_gc_time_stamps(r);
@@ -1096,18 +1096,18 @@
// You might think here that we could clear just the cards
// corresponding to the used region. But no: if we leave a dirty card
// in a region we might allocate into, then it would prevent that card
// from being enqueued, and cause it to be missed.
// Re: the performance cost: we shouldn't be doing full GC anyway!
- _mr_bs->clear(MemRegion(r->bottom(), r->end()));
+ _ct->clear(MemRegion(r->bottom(), r->end()));
return false;
}
};
void G1CollectedHeap::clear_rsets_post_compaction() {
- PostMCRemSetClearClosure rs_clear(this, g1_barrier_set());
+ PostMCRemSetClearClosure rs_clear(this, g1_card_table());
heap_region_iterate(&rs_clear);
}
class RebuildRSOutOfRegionClosure: public HeapRegionClosure {
G1CollectedHeap* _g1h;
@@ -1348,11 +1348,11 @@
#ifdef TRACESPINNING
ParallelTaskTerminator::print_termination_counts();
#endif
// Discard all rset updates
- JavaThread::dirty_card_queue_set().abandon_logs();
+ G1BarrierSet::dirty_card_queue_set().abandon_logs();
assert(dirty_card_queue_set().completed_buffers_num() == 0, "DCQS should be empty");
// At this point there should be no regions in the
// entire heap tagged as young.
assert(check_young_list_empty(), "young list should be empty at this point");
@@ -1830,21 +1830,22 @@
heap_alignment);
initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
// Create the barrier set for the entire reserved region.
- G1SATBCardTableLoggingModRefBS* bs
- = new G1SATBCardTableLoggingModRefBS(reserved_region());
+ G1CardTable* ct = new G1CardTable(reserved_region());
+ ct->initialize();
+ G1BarrierSet* bs = new G1BarrierSet(ct);
bs->initialize();
- assert(bs->is_a(BarrierSet::G1SATBCTLogging), "sanity");
+ assert(bs->is_a(BarrierSet::G1BarrierSet), "sanity");
set_barrier_set(bs);
// Create the hot card cache.
_hot_card_cache = new G1HotCardCache(this);
// Also create a G1 rem set.
- _g1_rem_set = new G1RemSet(this, g1_barrier_set(), _hot_card_cache);
+ _g1_rem_set = new G1RemSet(this, ct, _hot_card_cache);
// Carve out the G1 part of the heap.
ReservedSpace g1_rs = heap_rs.first_part(max_byte_size);
size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size();
G1RegionToSpaceMapper* heap_storage =
@@ -1866,15 +1867,15 @@
G1RegionToSpaceMapper* bot_storage =
create_aux_memory_mapper("Block Offset Table",
G1BlockOffsetTable::compute_size(g1_rs.size() / HeapWordSize),
G1BlockOffsetTable::heap_map_factor());
- ReservedSpace cardtable_rs(G1SATBCardTableLoggingModRefBS::compute_size(g1_rs.size() / HeapWordSize));
+ ReservedSpace cardtable_rs(G1CardTable::compute_size(g1_rs.size() / HeapWordSize));
G1RegionToSpaceMapper* cardtable_storage =
create_aux_memory_mapper("Card Table",
- G1SATBCardTableLoggingModRefBS::compute_size(g1_rs.size() / HeapWordSize),
- G1SATBCardTableLoggingModRefBS::heap_map_factor());
+ G1CardTable::compute_size(g1_rs.size() / HeapWordSize),
+ G1CardTable::heap_map_factor());
G1RegionToSpaceMapper* card_counts_storage =
create_aux_memory_mapper("Card Counts Table",
G1CardCounts::compute_size(g1_rs.size() / HeapWordSize),
G1CardCounts::heap_map_factor());
@@ -1884,11 +1885,11 @@
create_aux_memory_mapper("Prev Bitmap", bitmap_size, G1CMBitMap::heap_map_factor());
G1RegionToSpaceMapper* next_bitmap_storage =
create_aux_memory_mapper("Next Bitmap", bitmap_size, G1CMBitMap::heap_map_factor());
_hrm.initialize(heap_storage, prev_bitmap_storage, next_bitmap_storage, bot_storage, cardtable_storage, card_counts_storage);
- g1_barrier_set()->initialize(cardtable_storage);
+ g1_card_table()->initialize(cardtable_storage);
// Do later initialization work for concurrent refinement.
_hot_card_cache->initialize(card_counts_storage);
// 6843694 - ensure that the maximum region index can fit
// in the remembered set structures.
@@ -1931,16 +1932,16 @@
}
// Perform any initialization actions delegated to the policy.
g1_policy()->init(this, &_collection_set);
- JavaThread::satb_mark_queue_set().initialize(SATB_Q_CBL_mon,
+ G1BarrierSet::satb_mark_queue_set().initialize(SATB_Q_CBL_mon,
SATB_Q_FL_lock,
G1SATBProcessCompletedThreshold,
Shared_SATB_Q_lock);
- JavaThread::dirty_card_queue_set().initialize(_refine_cte_cl,
+ G1BarrierSet::dirty_card_queue_set().initialize(_refine_cte_cl,
DirtyCardQ_CBL_mon,
DirtyCardQ_FL_lock,
(int)concurrent_g1_refine()->yellow_zone(),
(int)concurrent_g1_refine()->red_zone(),
Shared_DirtyCardQ_lock,
@@ -1951,11 +1952,11 @@
DirtyCardQ_CBL_mon,
DirtyCardQ_FL_lock,
-1, // never trigger processing
-1, // no limit on length
Shared_DirtyCardQ_lock,
- &JavaThread::dirty_card_queue_set());
+ &G1BarrierSet::dirty_card_queue_set());
// Here we allocate the dummy HeapRegion that is required by the
// G1AllocRegion class.
HeapRegion* dummy_region = _hrm.get_dummy_region();
@@ -1992,10 +1993,18 @@
if (G1StringDedup::is_enabled()) {
G1StringDedup::stop();
}
}
+void G1CollectedHeap::safepoint_synchronize_begin() {
+ SuspendibleThreadSet::synchronize();
+}
+
+void G1CollectedHeap::safepoint_synchronize_end() {
+ SuspendibleThreadSet::desynchronize();
+}
+
size_t G1CollectedHeap::conservative_max_heap_alignment() {
return HeapRegion::max_region_size();
}
void G1CollectedHeap::post_initialize() {
@@ -2121,11 +2130,11 @@
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 = JavaThread::dirty_card_queue_set();
+ DirtyCardQueueSet& dcqs = G1BarrierSet::dirty_card_queue_set();
size_t n_completed_buffers = 0;
while (dcqs.apply_closure_to_completed_buffer(cl, worker_i, 0, true)) {
n_completed_buffers++;
}
g1_policy()->phase_times()->record_thread_work_item(G1GCPhaseTimes::UpdateRS, worker_i, n_completed_buffers);
@@ -2497,10 +2506,14 @@
bool G1CollectedHeap::request_concurrent_phase(const char* phase) {
return _cmThread->request_concurrent_phase(phase);
}
+void G1CollectedHeap::verify_nmethod_roots(nmethod* nmethod) {
+
+}
+
class PrintRegionClosure: public HeapRegionClosure {
outputStream* _st;
public:
PrintRegionClosure(outputStream* st) : _st(st) {}
bool doHeapRegion(HeapRegion* r) {
@@ -2775,11 +2788,11 @@
while (curr != NULL) {
DirtyCardQueue& dcq = curr->dirty_card_queue();
extra_cards += dcq.size();
curr = curr->next();
}
- DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
+ DirtyCardQueueSet& dcqs = G1BarrierSet::dirty_card_queue_set();
size_t buffer_size = dcqs.buffer_size();
size_t buffer_num = dcqs.completed_buffers_num();
// PtrQueueSet::buffer_size() and PtrQueue:size() return sizes
// in bytes - not the number of 'entries'. We need to convert
@@ -2855,11 +2868,11 @@
public:
RegisterHumongousWithInCSetFastTestClosure()
: _total_humongous(0),
_candidate_humongous(0),
- _dcq(&JavaThread::dirty_card_queue_set()) {
+ _dcq(&G1BarrierSet::dirty_card_queue_set()) {
}
virtual bool doHeapRegion(HeapRegion* r) {
if (!r->is_starts_humongous()) {
return false;
@@ -2878,21 +2891,21 @@
// re-evaluation of their remembered set entries during the following evacuation
// phase.
if (!r->rem_set()->is_empty()) {
guarantee(r->rem_set()->occupancy_less_or_equal_than(G1RSetSparseRegionEntries),
"Found a not-small remembered set here. This is inconsistent with previous assumptions.");
- G1SATBCardTableLoggingModRefBS* bs = g1h->g1_barrier_set();
+ G1CardTable* ct = g1h->g1_card_table();
HeapRegionRemSetIterator hrrs(r->rem_set());
size_t card_index;
while (hrrs.has_next(card_index)) {
- jbyte* card_ptr = (jbyte*)bs->byte_for_index(card_index);
+ jbyte* card_ptr = (jbyte*)ct->byte_for_index(card_index);
// The remembered set might contain references to already freed
// regions. Filter out such entries to avoid failing card table
// verification.
- if (g1h->is_in_closed_subset(bs->addr_for(card_ptr))) {
- if (*card_ptr != CardTableModRefBS::dirty_card_val()) {
- *card_ptr = CardTableModRefBS::dirty_card_val();
+ if (g1h->is_in_closed_subset(ct->addr_for(card_ptr))) {
+ if (*card_ptr != G1CardTable::dirty_card_val()) {
+ *card_ptr = G1CardTable::dirty_card_val();
_dcq.enqueue(card_ptr);
}
}
}
assert(hrrs.n_yielded() == r->rem_set()->occupied(),
@@ -3932,11 +3945,11 @@
G1RedirtyLoggedCardsTask redirty_task(&dirty_card_queue_set(), this);
dirty_card_queue_set().reset_for_par_iteration();
workers()->run_task(&redirty_task);
- DirtyCardQueueSet& dcq = JavaThread::dirty_card_queue_set();
+ 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);
}
@@ -5458,20 +5471,18 @@
void do_oop(oop* p) { do_oop_work(p); }
void do_oop(narrowOop* p) { do_oop_work(p); }
};
void G1CollectedHeap::register_nmethod(nmethod* nm) {
- CollectedHeap::register_nmethod(nm);
-
+ assert_locked_or_safepoint(CodeCache_lock);
guarantee(nm != NULL, "sanity");
RegisterNMethodOopClosure reg_cl(this, nm);
nm->oops_do(®_cl);
}
void G1CollectedHeap::unregister_nmethod(nmethod* nm) {
- CollectedHeap::unregister_nmethod(nm);
-
+ assert_locked_or_safepoint(CodeCache_lock);
guarantee(nm != NULL, "sanity");
UnregisterNMethodOopClosure reg_cl(this, nm);
nm->oops_do(®_cl, true);
}
< prev index next >