代码拉取完成，页面将自动刷新
同步操作将从 src-openEuler/openjdk-1.8.0 强制同步，此操作会覆盖自 Fork 仓库以来所做的任何修改，且无法恢复！！！
确定后同步将在后台操作，完成时将刷新页面，请耐心等待。
From abe008c9f30db79afb44f87bd8cab37bd1486e4b Mon Sep 17 00:00:00 2001
From: wangkun <wangkun49@huawei.com>
Date: Mon, 13 Sep 2021 17:34:39 +0800
Subject: [PATCH 19/23] Parallel Full GC for G1.
Summary:gc:g1:Parallel Full GC for G1. (prepare/adjust/compact in parallel; uses claimer instead of claim value; code clean)
LLT: N/A
Patch Type:huawei
Bug url: N/A
---
.../gc_implementation/g1/concurrentMark.cpp | 66 +-
.../g1/g1BlockOffsetTable.inline.hpp | 4 +-
.../gc_implementation/g1/g1CollectedHeap.cpp | 168 +----
.../gc_implementation/g1/g1CollectedHeap.hpp | 21 +-
.../g1/g1CollectorPolicy.cpp | 16 +-
.../vm/gc_implementation/g1/g1EvacFailure.hpp | 13 +-
.../vm/gc_implementation/g1/g1MarkSweep.cpp | 583 ++++++++++++++++--
.../vm/gc_implementation/g1/g1MarkSweep.hpp | 45 +-
.../gc_implementation/g1/g1MarkSweep_ext.cpp | 31 -
.../vm/gc_implementation/g1/g1RemSet.cpp | 7 +-
.../vm/gc_implementation/g1/g1RemSet.hpp | 2 +-
.../vm/gc_implementation/g1/g1_globals.hpp | 3 +
.../vm/gc_implementation/g1/heapRegion.cpp | 20 +-
.../vm/gc_implementation/g1/heapRegion.hpp | 44 +-
.../g1/heapRegionManager.cpp | 42 +-
.../g1/heapRegionManager.hpp | 25 +-
hotspot/src/share/vm/memory/space.cpp | 9 +-
hotspot/src/share/vm/memory/space.hpp | 6 +-
hotspot/src/share/vm/memory/space.inline.hpp | 61 ++
hotspot/src/share/vm/runtime/mutexLocker.cpp | 4 +
hotspot/src/share/vm/runtime/mutexLocker.hpp | 2 +
...rReclaimHumongousRegionsClearMarkBits.java | 4 +-
...tEagerReclaimHumongousRegionsWithRefs.java | 4 +-
.../jfr/event/gc/detailed/ExecuteOOMApp.java | 4 +-
.../TestG1ConcurrentModeFailureEvent.java | 36 +-
25 files changed, 789 insertions(+), 431 deletions(-)
delete mode 100644 hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep_ext.cpp
diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
index 52bd8cc5e..447bee183 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
@@ -1666,6 +1666,8 @@ protected:
int _failures;
bool _verbose;
+ HeapRegionClaimer _hrclaimer;
+
public:
G1ParVerifyFinalCountTask(G1CollectedHeap* g1h,
BitMap* region_bm, BitMap* card_bm,
@@ -1687,6 +1689,7 @@ public:
} else {
_n_workers = 1;
}
+ _hrclaimer.set_workers(_n_workers);
assert(_expected_card_bm->size() == _actual_card_bm->size(), "sanity");
assert(_expected_region_bm->size() == _actual_region_bm->size(), "sanity");
@@ -1706,8 +1709,7 @@ public:
if (G1CollectedHeap::use_parallel_gc_threads()) {
_g1h->heap_region_par_iterate_chunked(&verify_cl,
worker_id,
- _n_workers,
- HeapRegion::VerifyCountClaimValue);
+ &_hrclaimer);
} else {
_g1h->heap_region_iterate(&verify_cl);
}
@@ -1796,6 +1798,7 @@ protected:
BitMap* _actual_card_bm;
uint _n_workers;
+ HeapRegionClaimer _hrclaimer;
public:
G1ParFinalCountTask(G1CollectedHeap* g1h, BitMap* region_bm, BitMap* card_bm)
@@ -1812,6 +1815,7 @@ public:
} else {
_n_workers = 1;
}
+ _hrclaimer.set_workers(_n_workers);
}
void work(uint worker_id) {
@@ -1824,8 +1828,7 @@ public:
if (G1CollectedHeap::use_parallel_gc_threads()) {
_g1h->heap_region_par_iterate_chunked(&final_update_cl,
worker_id,
- _n_workers,
- HeapRegion::FinalCountClaimValue);
+ &_hrclaimer);
} else {
_g1h->heap_region_iterate(&final_update_cl);
}
@@ -1912,12 +1915,15 @@ protected:
size_t _max_live_bytes;
size_t _freed_bytes;
FreeRegionList* _cleanup_list;
+ HeapRegionClaimer _hrclaimer;
public:
G1ParNoteEndTask(G1CollectedHeap* g1h,
- FreeRegionList* cleanup_list) :
+ FreeRegionList* cleanup_list,
+ uint n_workers) :
AbstractGangTask("G1 note end"), _g1h(g1h),
- _max_live_bytes(0), _freed_bytes(0), _cleanup_list(cleanup_list) { }
+ _max_live_bytes(0), _freed_bytes(0),
+ _cleanup_list(cleanup_list), _hrclaimer(n_workers) { }
void work(uint worker_id) {
double start = os::elapsedTime();
@@ -1926,9 +1932,7 @@ public:
G1NoteEndOfConcMarkClosure g1_note_end(_g1h, &local_cleanup_list,
&hrrs_cleanup_task);
if (G1CollectedHeap::use_parallel_gc_threads()) {
- _g1h->heap_region_par_iterate_chunked(&g1_note_end, worker_id,
- _g1h->workers()->active_workers(),
- HeapRegion::NoteEndClaimValue);
+ _g1h->heap_region_par_iterate_chunked(&g1_note_end, worker_id, &_hrclaimer);
} else {
_g1h->heap_region_iterate(&g1_note_end);
}
@@ -1974,16 +1978,16 @@ protected:
G1RemSet* _g1rs;
BitMap* _region_bm;
BitMap* _card_bm;
+ HeapRegionClaimer _hrclaimer;
public:
- G1ParScrubRemSetTask(G1CollectedHeap* g1h,
- BitMap* region_bm, BitMap* card_bm) :
+ G1ParScrubRemSetTask(G1CollectedHeap* g1h, BitMap* region_bm,
+ BitMap* card_bm, uint n_workers) :
AbstractGangTask("G1 ScrubRS"), _g1rs(g1h->g1_rem_set()),
- _region_bm(region_bm), _card_bm(card_bm) { }
+ _region_bm(region_bm), _card_bm(card_bm), _hrclaimer(n_workers) { }
void work(uint worker_id) {
if (G1CollectedHeap::use_parallel_gc_threads()) {
- _g1rs->scrub_par(_region_bm, _card_bm, worker_id,
- HeapRegion::ScrubRemSetClaimValue);
+ _g1rs->scrub_par(_region_bm, _card_bm, worker_id, &_hrclaimer);
} else {
_g1rs->scrub(_region_bm, _card_bm);
}
@@ -2026,9 +2030,6 @@ void ConcurrentMark::cleanup() {
G1ParFinalCountTask g1_par_count_task(g1h, &_region_bm, &_card_bm);
if (G1CollectedHeap::use_parallel_gc_threads()) {
- assert(g1h->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
- "sanity check");
-
g1h->set_par_threads();
n_workers = g1h->n_par_threads();
assert(g1h->n_par_threads() == n_workers,
@@ -2036,9 +2037,6 @@ void ConcurrentMark::cleanup() {
g1h->workers()->run_task(&g1_par_count_task);
// Done with the parallel phase so reset to 0.
g1h->set_par_threads(0);
-
- assert(g1h->check_heap_region_claim_values(HeapRegion::FinalCountClaimValue),
- "sanity check");
} else {
n_workers = 1;
g1_par_count_task.work(0);
@@ -2063,9 +2061,6 @@ void ConcurrentMark::cleanup() {
g1h->workers()->run_task(&g1_par_verify_task);
// Done with the parallel phase so reset to 0.
g1h->set_par_threads(0);
-
- assert(g1h->check_heap_region_claim_values(HeapRegion::VerifyCountClaimValue),
- "sanity check");
} else {
g1_par_verify_task.work(0);
}
@@ -2091,14 +2086,11 @@ void ConcurrentMark::cleanup() {
g1h->reset_gc_time_stamp();
// Note end of marking in all heap regions.
- G1ParNoteEndTask g1_par_note_end_task(g1h, &_cleanup_list);
+ G1ParNoteEndTask g1_par_note_end_task(g1h, &_cleanup_list, n_workers);
if (G1CollectedHeap::use_parallel_gc_threads()) {
g1h->set_par_threads((int)n_workers);
g1h->workers()->run_task(&g1_par_note_end_task);
g1h->set_par_threads(0);
-
- assert(g1h->check_heap_region_claim_values(HeapRegion::NoteEndClaimValue),
- "sanity check");
} else {
g1_par_note_end_task.work(0);
}
@@ -2115,15 +2107,11 @@ void ConcurrentMark::cleanup() {
// regions.
if (G1ScrubRemSets) {
double rs_scrub_start = os::elapsedTime();
- G1ParScrubRemSetTask g1_par_scrub_rs_task(g1h, &_region_bm, &_card_bm);
+ G1ParScrubRemSetTask g1_par_scrub_rs_task(g1h, &_region_bm, &_card_bm, n_workers);
if (G1CollectedHeap::use_parallel_gc_threads()) {
g1h->set_par_threads((int)n_workers);
g1h->workers()->run_task(&g1_par_scrub_rs_task);
g1h->set_par_threads(0);
-
- assert(g1h->check_heap_region_claim_values(
- HeapRegion::ScrubRemSetClaimValue),
- "sanity check");
} else {
g1_par_scrub_rs_task.work(0);
}
@@ -3299,6 +3287,7 @@ protected:
BitMap* _cm_card_bm;
uint _max_worker_id;
int _active_workers;
+ HeapRegionClaimer _hrclaimer;
public:
G1AggregateCountDataTask(G1CollectedHeap* g1h,
@@ -3309,15 +3298,14 @@ public:
AbstractGangTask("Count Aggregation"),
_g1h(g1h), _cm(cm), _cm_card_bm(cm_card_bm),
_max_worker_id(max_worker_id),
- _active_workers(n_workers) { }
+ _active_workers(n_workers),
+ _hrclaimer(_active_workers) { }
void work(uint worker_id) {
AggregateCountDataHRClosure cl(_g1h, _cm_card_bm, _max_worker_id);
if (G1CollectedHeap::use_parallel_gc_threads()) {
- _g1h->heap_region_par_iterate_chunked(&cl, worker_id,
- _active_workers,
- HeapRegion::AggregateCountClaimValue);
+ _g1h->heap_region_par_iterate_chunked(&cl, worker_id, &_hrclaimer);
} else {
_g1h->heap_region_iterate(&cl);
}
@@ -3334,15 +3322,9 @@ void ConcurrentMark::aggregate_count_data() {
_max_worker_id, n_workers);
if (G1CollectedHeap::use_parallel_gc_threads()) {
- assert(_g1h->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
- "sanity check");
_g1h->set_par_threads(n_workers);
_g1h->workers()->run_task(&g1_par_agg_task);
_g1h->set_par_threads(0);
-
- assert(_g1h->check_heap_region_claim_values(HeapRegion::AggregateCountClaimValue),
- "sanity check");
- _g1h->reset_heap_region_claim_values();
} else {
g1_par_agg_task.work(0);
}
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp
index b2d3b282b..912acdbe0 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp
@@ -134,7 +134,9 @@ inline HeapWord*
G1BlockOffsetArray::block_at_or_preceding(const void* addr,
bool has_max_index,
size_t max_index) const {
- assert(_array->offset_array(0) == 0, "objects can't cross covered areas");
+ assert(_array->offset_array(_array->index_for(
+ G1CollectedHeap::heap()->heap_region_containing(addr)->bottom())) == 0,
+ "objects can't cross covered areas");
size_t index = _array->index_for(addr);
// We must make sure that the offset table entry we use is valid. If
// "addr" is past the end, start at the last known one and go forward.
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
index ce015b85d..1afc2e331 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
@@ -383,7 +383,6 @@ void G1RegionMappingChangedListener::on_commit(uint start_idx, size_t num_region
void G1CollectedHeap::run_task(AbstractGangTask* task) {
workers()->run_task(task);
- reset_heap_region_claim_values();
}
void G1CollectedHeap::push_dirty_cards_region(HeapRegion* hr)
@@ -1215,17 +1214,17 @@ public:
class ParRebuildRSTask: public AbstractGangTask {
G1CollectedHeap* _g1;
+ HeapRegionClaimer _hrclaimer;
+
public:
ParRebuildRSTask(G1CollectedHeap* g1)
: AbstractGangTask("ParRebuildRSTask"),
- _g1(g1)
+ _g1(g1), _hrclaimer(g1->workers()->active_workers())
{ }
void work(uint worker_id) {
RebuildRSOutOfRegionClosure rebuild_rs(_g1, worker_id);
- _g1->heap_region_par_iterate_chunked(&rebuild_rs, worker_id,
- _g1->workers()->active_workers(),
- HeapRegion::RebuildRSClaimValue);
+ _g1->heap_region_par_iterate_chunked(&rebuild_rs, worker_id, &_hrclaimer);
}
};
@@ -1454,8 +1453,6 @@ bool G1CollectedHeap::do_collection(bool explicit_gc,
set_par_threads(n_workers);
ParRebuildRSTask rebuild_rs_task(this);
- assert(check_heap_region_claim_values(
- HeapRegion::InitialClaimValue), "sanity check");
assert(UseDynamicNumberOfGCThreads ||
workers()->active_workers() == workers()->total_workers(),
"Unless dynamic should use total workers");
@@ -1465,9 +1462,6 @@ bool G1CollectedHeap::do_collection(bool explicit_gc,
set_par_threads(workers()->active_workers());
workers()->run_task(&rebuild_rs_task);
set_par_threads(0);
- assert(check_heap_region_claim_values(
- HeapRegion::RebuildRSClaimValue), "sanity check");
- reset_heap_region_claim_values();
} else {
RebuildRSOutOfRegionClosure rebuild_rs(this);
heap_region_iterate(&rebuild_rs);
@@ -1553,7 +1547,6 @@ bool G1CollectedHeap::do_collection(bool explicit_gc,
gc_timer->register_gc_end();
gc_tracer->report_gc_end(gc_timer->gc_end(), gc_timer->time_partitions());
}
-
return true;
}
@@ -1574,8 +1567,8 @@ G1CollectedHeap::
resize_if_necessary_after_full_collection(size_t word_size) {
// Include the current allocation, if any, and bytes that will be
// pre-allocated to support collections, as "used".
- const size_t used_after_gc = used();
const size_t capacity_after_gc = capacity();
+ const size_t used_after_gc = capacity_after_gc - num_free_regions() * HeapRegion::GrainBytes;
const size_t free_after_gc = capacity_after_gc - used_after_gc;
// This is enforced in arguments.cpp.
@@ -2678,13 +2671,15 @@ class G1ParallelObjectIterator : public ParallelObjectIterator {
private:
G1CollectedHeap* _heap;
uint _num_threads;
+ HeapRegionClaimer _claimer;
public:
G1ParallelObjectIterator(uint thread_num) :
- _heap(G1CollectedHeap::heap()),_num_threads(thread_num) {}
+ _heap(G1CollectedHeap::heap()),_num_threads(thread_num),
+ _claimer(thread_num) { }
virtual void object_iterate(ObjectClosure* cl, uint worker_id) {
- _heap->object_iterate_parallel(cl, worker_id,_num_threads);
+ _heap->object_iterate_parallel(cl, worker_id, &_claimer);
}
};
@@ -2692,9 +2687,10 @@ ParallelObjectIterator* G1CollectedHeap::parallel_object_iterator(uint thread_nu
return new G1ParallelObjectIterator(thread_num);
}
-void G1CollectedHeap::object_iterate_parallel(ObjectClosure* cl, uint worker_id, uint num_workers) {
+void G1CollectedHeap::object_iterate_parallel(ObjectClosure* cl, uint worker_id,
+ HeapRegionClaimer* claimer) {
IterateObjectClosureRegionClosure blk(cl);
- heap_region_par_iterate_chunked(&blk, worker_id, num_workers, HeapRegion::ParInspectClaimValue);
+ heap_region_par_iterate_chunked(&blk, worker_id, claimer);
}
@@ -2722,109 +2718,10 @@ void G1CollectedHeap::heap_region_iterate(HeapRegionClosure* cl) const {
void
G1CollectedHeap::heap_region_par_iterate_chunked(HeapRegionClosure* cl,
uint worker_id,
- uint num_workers,
- jint claim_value) const {
- _hrm.par_iterate(cl, worker_id, num_workers, claim_value);
-}
-
-class ResetClaimValuesClosure: public HeapRegionClosure {
-public:
- bool doHeapRegion(HeapRegion* r) {
- r->set_claim_value(HeapRegion::InitialClaimValue);
- return false;
- }
-};
-
-void G1CollectedHeap::reset_heap_region_claim_values() {
- ResetClaimValuesClosure blk;
- heap_region_iterate(&blk);
-}
-
-void G1CollectedHeap::reset_cset_heap_region_claim_values() {
- ResetClaimValuesClosure blk;
- collection_set_iterate(&blk);
-}
-
-#ifdef ASSERT
-// This checks whether all regions in the heap have the correct claim
-// value. I also piggy-backed on this a check to ensure that the
-// humongous_start_region() information on "continues humongous"
-// regions is correct.
-
-class CheckClaimValuesClosure : public HeapRegionClosure {
-private:
- jint _claim_value;
- uint _failures;
- HeapRegion* _sh_region;
-
-public:
- CheckClaimValuesClosure(jint claim_value) :
- _claim_value(claim_value), _failures(0), _sh_region(NULL) { }
- bool doHeapRegion(HeapRegion* r) {
- if (r->claim_value() != _claim_value) {
- gclog_or_tty->print_cr("Region " HR_FORMAT ", "
- "claim value = %d, should be %d",
- HR_FORMAT_PARAMS(r),
- r->claim_value(), _claim_value);
- ++_failures;
- }
- if (!r->isHumongous()) {
- _sh_region = NULL;
- } else if (r->startsHumongous()) {
- _sh_region = r;
- } else if (r->continuesHumongous()) {
- if (r->humongous_start_region() != _sh_region) {
- gclog_or_tty->print_cr("Region " HR_FORMAT ", "
- "HS = " PTR_FORMAT ", should be " PTR_FORMAT,
- HR_FORMAT_PARAMS(r),
- p2i(r->humongous_start_region()),
- p2i(_sh_region));
- ++_failures;
- }
- }
- return false;
- }
- uint failures() { return _failures; }
-};
-
-bool G1CollectedHeap::check_heap_region_claim_values(jint claim_value) {
- CheckClaimValuesClosure cl(claim_value);
- heap_region_iterate(&cl);
- return cl.failures() == 0;
+ HeapRegionClaimer *hrclaimer) const {
+ _hrm.par_iterate(cl, worker_id, hrclaimer);
}
-class CheckClaimValuesInCSetHRClosure: public HeapRegionClosure {
-private:
- jint _claim_value;
- uint _failures;
-
-public:
- CheckClaimValuesInCSetHRClosure(jint claim_value) :
- _claim_value(claim_value), _failures(0) { }
-
- uint failures() { return _failures; }
-
- bool doHeapRegion(HeapRegion* hr) {
- assert(hr->in_collection_set(), "how?");
- assert(!hr->isHumongous(), "H-region in CSet");
- if (hr->claim_value() != _claim_value) {
- gclog_or_tty->print_cr("CSet Region " HR_FORMAT ", "
- "claim value = %d, should be %d",
- HR_FORMAT_PARAMS(hr),
- hr->claim_value(), _claim_value);
- _failures += 1;
- }
- return false;
- }
-};
-
-bool G1CollectedHeap::check_cset_heap_region_claim_values(jint claim_value) {
- CheckClaimValuesInCSetHRClosure cl(claim_value);
- collection_set_iterate(&cl);
- return cl.failures() == 0;
-}
-#endif // ASSERT
-
// Clear the cached CSet starting regions and (more importantly)
// the time stamps. Called when we reset the GC time stamp.
void G1CollectedHeap::clear_cset_start_regions() {
@@ -3348,6 +3245,7 @@ private:
G1CollectedHeap* _g1h;
VerifyOption _vo;
bool _failures;
+ HeapRegionClaimer _hrclaimer;
public:
// _vo == UsePrevMarking -> use "prev" marking information,
@@ -3357,7 +3255,8 @@ public:
AbstractGangTask("Parallel verify task"),
_g1h(g1h),
_vo(vo),
- _failures(false) { }
+ _failures(false),
+ _hrclaimer(g1h->workers()->active_workers()) { }
bool failures() {
return _failures;
@@ -3366,9 +3265,7 @@ public:
void work(uint worker_id) {
HandleMark hm;
VerifyRegionClosure blk(true, _vo);
- _g1h->heap_region_par_iterate_chunked(&blk, worker_id,
- _g1h->workers()->active_workers(),
- HeapRegion::ParVerifyClaimValue);
+ _g1h->heap_region_par_iterate_chunked(&blk, worker_id, &_hrclaimer);
if (blk.failures()) {
_failures = true;
}
@@ -3411,9 +3308,6 @@ void G1CollectedHeap::verify(bool silent, VerifyOption vo) {
if (!silent) { gclog_or_tty->print("HeapRegions "); }
if (GCParallelVerificationEnabled && ParallelGCThreads > 1) {
- assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue),
- "sanity check");
-
G1ParVerifyTask task(this, vo);
assert(UseDynamicNumberOfGCThreads ||
workers()->active_workers() == workers()->total_workers(),
@@ -3425,16 +3319,6 @@ void G1CollectedHeap::verify(bool silent, VerifyOption vo) {
if (task.failures()) {
failures = true;
}
-
- // Checks that the expected amount of parallel work was done.
- // The implication is that n_workers is > 0.
- assert(check_heap_region_claim_values(HeapRegion::ParVerifyClaimValue),
- "sanity check");
-
- reset_heap_region_claim_values();
-
- assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue),
- "sanity check");
} else {
VerifyRegionClosure blk(false, vo);
heap_region_iterate(&blk);
@@ -4164,8 +4048,6 @@ G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) {
}
assert(check_young_list_well_formed(), "young list should be well formed");
- assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue),
- "sanity check");
// Don't dynamically change the number of GC threads this early. A value of
// 0 is used to indicate serial work. When parallel work is done,
@@ -4508,8 +4390,6 @@ void G1CollectedHeap::finalize_for_evac_failure() {
}
void G1CollectedHeap::remove_self_forwarding_pointers() {
- assert(check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity");
-
double remove_self_forwards_start = os::elapsedTime();
G1ParRemoveSelfForwardPtrsTask rsfp_task(this);
@@ -4522,13 +4402,6 @@ void G1CollectedHeap::remove_self_forwarding_pointers() {
rsfp_task.work(0);
}
- assert(check_cset_heap_region_claim_values(HeapRegion::ParEvacFailureClaimValue), "sanity");
-
- // Reset the claim values in the regions in the collection set.
- reset_cset_heap_region_claim_values();
-
- assert(check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity");
-
// Now restore saved marks, if any.
assert(_objs_with_preserved_marks.size() ==
_preserved_marks_of_objs.size(), "Both or none.");
@@ -6000,11 +5873,6 @@ void G1CollectedHeap::evacuate_collection_set(EvacuationInfo& evacuation_info) {
purge_code_root_memory();
- if (g1_policy()->during_initial_mark_pause()) {
- // Reset the claim values set during marking the strong code roots
- reset_heap_region_claim_values();
- }
-
finalize_for_evac_failure();
if (evacuation_failed()) {
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
index f4ab7c0bd..2858ebfba 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
@@ -216,6 +216,7 @@ class G1CollectedHeap : public SharedHeap {
friend class CountRCClosure;
friend class EvacPopObjClosure;
friend class G1ParCleanupCTTask;
+ friend class HeapRegionClaimer;
friend class G1FreeHumongousRegionClosure;
friend class FreeRegionList;
@@ -1294,7 +1295,7 @@ public:
void cleanUpCardTable();
// Iteration functions.
- void object_iterate_parallel(ObjectClosure* cl, uint worker_id, uint num_workers);
+ void object_iterate_parallel(ObjectClosure* cl, uint worker_id, HeapRegionClaimer* claimer);
// Iterate over all the ref-containing fields of all objects, calling
// "cl.do_oop" on each.
@@ -1338,23 +1339,7 @@ public:
// i.e., that a closure never attempt to abort a traversal.
void heap_region_par_iterate_chunked(HeapRegionClosure* cl,
uint worker_id,
- uint num_workers,
- jint claim_value) const;
-
- // It resets all the region claim values to the default.
- void reset_heap_region_claim_values();
-
- // Resets the claim values of regions in the current
- // collection set to the default.
- void reset_cset_heap_region_claim_values();
-
-#ifdef ASSERT
- bool check_heap_region_claim_values(jint claim_value);
-
- // Same as the routine above but only checks regions in the
- // current collection set.
- bool check_cset_heap_region_claim_values(jint claim_value);
-#endif // ASSERT
+ HeapRegionClaimer *hrclaimer) const;
// Clear the cached cset start regions and (more importantly)
// the time stamps. Called when we reset the GC time stamp.
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
index 237932465..6d817883a 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
@@ -1606,19 +1606,19 @@ class ParKnownGarbageTask: public AbstractGangTask {
CollectionSetChooser* _hrSorted;
uint _chunk_size;
G1CollectedHeap* _g1;
+ HeapRegionClaimer _hrclaimer;
+
public:
- ParKnownGarbageTask(CollectionSetChooser* hrSorted, uint chunk_size) :
+ ParKnownGarbageTask(CollectionSetChooser* hrSorted, uint chunk_size, uint n_workers) :
AbstractGangTask("ParKnownGarbageTask"),
_hrSorted(hrSorted), _chunk_size(chunk_size),
- _g1(G1CollectedHeap::heap()) { }
+ _g1(G1CollectedHeap::heap()), _hrclaimer(n_workers) { }
void work(uint worker_id) {
ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size);
// Back to zero for the claim value.
- _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, worker_id,
- _g1->workers()->active_workers(),
- HeapRegion::InitialClaimValue);
+ _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, worker_id, &_hrclaimer);
}
};
@@ -1650,11 +1650,9 @@ G1CollectorPolicy::record_concurrent_mark_cleanup_end(int no_of_gc_threads) {
_collectionSetChooser->prepare_for_par_region_addition(_g1->num_regions(),
WorkUnit);
ParKnownGarbageTask parKnownGarbageTask(_collectionSetChooser,
- (int) WorkUnit);
+ (int) WorkUnit,
+ no_of_gc_threads);
_g1->workers()->run_task(&parKnownGarbageTask);
-
- assert(_g1->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
- "sanity check");
} else {
KnownGarbageClosure knownGarbagecl(_collectionSetChooser);
_g1->heap_region_iterate(&knownGarbagecl);
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1EvacFailure.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1EvacFailure.hpp
index e62834010..f3930a89d 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1EvacFailure.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1EvacFailure.hpp
@@ -177,15 +177,16 @@ class RemoveSelfForwardPtrHRClosure: public HeapRegionClosure {
G1CollectedHeap* _g1h;
ConcurrentMark* _cm;
uint _worker_id;
+ HeapRegionClaimer* _hrclaimer;
DirtyCardQueue _dcq;
UpdateRSetDeferred _update_rset_cl;
public:
RemoveSelfForwardPtrHRClosure(G1CollectedHeap* g1h,
- uint worker_id) :
+ uint worker_id, HeapRegionClaimer* hrclaimer) :
_g1h(g1h), _dcq(&g1h->dirty_card_queue_set()), _update_rset_cl(g1h, &_dcq),
- _worker_id(worker_id), _cm(_g1h->concurrent_mark()) {
+ _worker_id(worker_id), _hrclaimer(hrclaimer), _cm(_g1h->concurrent_mark()) {
}
bool doHeapRegion(HeapRegion *hr) {
@@ -195,7 +196,7 @@ public:
assert(!hr->isHumongous(), "sanity");
assert(hr->in_collection_set(), "bad CS");
- if (hr->claimHeapRegion(HeapRegion::ParEvacFailureClaimValue)) {
+ if (_hrclaimer->claim_region(hr->hrm_index())) {
if (hr->evacuation_failed()) {
RemoveSelfForwardPtrObjClosure rspc(_g1h, _cm, hr, &_update_rset_cl,
during_initial_mark,
@@ -233,14 +234,16 @@ public:
class G1ParRemoveSelfForwardPtrsTask: public AbstractGangTask {
protected:
G1CollectedHeap* _g1h;
+ HeapRegionClaimer _hrclaimer;
public:
G1ParRemoveSelfForwardPtrsTask(G1CollectedHeap* g1h) :
AbstractGangTask("G1 Remove Self-forwarding Pointers"),
- _g1h(g1h) { }
+ _g1h(g1h),
+ _hrclaimer(G1CollectedHeap::heap()->workers()->active_workers()) { }
void work(uint worker_id) {
- RemoveSelfForwardPtrHRClosure rsfp_cl(_g1h, worker_id);
+ RemoveSelfForwardPtrHRClosure rsfp_cl(_g1h, worker_id, &_hrclaimer);
HeapRegion* hr = _g1h->start_cset_region_for_worker(worker_id);
_g1h->collection_set_iterate_from(hr, &rsfp_cl);
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp
index 24115acaf..2a14b967a 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp
@@ -34,6 +34,7 @@
#include "gc_implementation/g1/g1RootProcessor.hpp"
#include "gc_implementation/g1/g1StringDedup.hpp"
#include "gc_implementation/shared/gcHeapSummary.hpp"
+#include "gc_implementation/shared/liveRange.hpp"
#include "gc_implementation/shared/gcTimer.hpp"
#include "gc_implementation/shared/gcTrace.hpp"
#include "gc_implementation/shared/gcTraceTime.hpp"
@@ -58,9 +59,173 @@
class HeapRegion;
+
+class G1FullGCCompactionPoint : public CompactPoint {
+ HeapRegion* _current_region;
+ HeapWord* _threshold;
+ HeapWord* _compaction_top;
+ GrowableArray<HeapRegion*>* _compaction_regions;
+ GrowableArrayIterator<HeapRegion*> _compaction_region_iterator;
+ GrowableArray<HeapRegion*>* _marked_huge_regions;
+
+ virtual HeapRegion* next_compaction_space() {
+ HeapRegion* next = *(++_compaction_region_iterator);
+ assert(next != NULL, "Must return valid region");
+ return next;
+ }
+
+public:
+ G1FullGCCompactionPoint() :
+ _current_region(NULL),
+ _threshold(NULL),
+ _compaction_top(NULL),
+ _compaction_regions(new (ResourceObj::C_HEAP, mtGC)
+ GrowableArray<HeapRegion*>(32/* initial size */, true, mtGC)),
+ _compaction_region_iterator(_compaction_regions->begin()),
+ _marked_huge_regions(new (ResourceObj::C_HEAP, mtGC)
+ GrowableArray<HeapRegion*>(32/* initial size */, true, mtGC)) {
+ }
+ virtual ~G1FullGCCompactionPoint() {
+ delete _compaction_regions;
+ delete _marked_huge_regions;
+ }
+
+ bool is_initialized() {
+ return _current_region != NULL;
+ }
+
+ void initialize(HeapRegion* hr, bool init_threshold) {
+ _current_region = hr;
+ initialize_values(init_threshold);
+ }
+
+ void initialize_values(bool init_threshold) {
+ _compaction_top = _current_region->compaction_top();
+ if (init_threshold) {
+ _threshold = _current_region->initialize_threshold();
+ }
+ }
+
+ void update() {
+ if (is_initialized()) {
+ _current_region->set_compaction_top(_compaction_top);
+ }
+ }
+
+ bool object_will_fit(size_t size) {
+ size_t space_left = pointer_delta(_current_region->end(), _compaction_top);
+ return size <= space_left;
+ }
+
+ void switch_region() {
+ // Save compaction top in the region.
+ _current_region->set_compaction_top(_compaction_top);
+ // Get the next region and re-initialize the values.
+ _current_region = next_compaction_space();
+ initialize_values(true);
+ }
+
+ void forward(oop object, size_t size) {
+ assert(_current_region != NULL, "Must have been initialized");
+
+ // Ensure the object fit in the current region.
+ while (!object_will_fit(size)) {
+ switch_region();
+ }
+
+ if ((HeapWord*)object != _compaction_top) {
+ object->forward_to(oop(_compaction_top));
+ } else {
+ object->init_mark();
+ }
+
+ // Update compaction values.
+ _compaction_top += size;
+ if (_compaction_top > _threshold) {
+ _threshold = _current_region->cross_threshold(_compaction_top - size, _compaction_top);
+ }
+ }
+
+ void add(HeapRegion* hr) {
+ _compaction_regions->append(hr);
+ }
+ void add_huge(HeapRegion* hr) {
+ _marked_huge_regions->append(hr);
+ }
+ HeapRegion* current_region() {
+ return *_compaction_region_iterator;
+ }
+ const GrowableArray<HeapRegion*>* regions() const {
+ return _compaction_regions;
+ }
+ const GrowableArray<HeapRegion*>* huge_regions() const {
+ return _marked_huge_regions;
+ }
+
+ HeapRegion* remove_last() {
+ return _compaction_regions->pop();
+ }
+
+ bool has_region() {
+ return !_compaction_regions->is_empty();
+ }
+};
+
+class G1FullGCCompactionPoints : StackObj {
+private:
+ G1FullGCCompactionPoint** _cps;
+ uint _num_workers;
+ G1FullGCCompactionPoint* _serial_compaction_point;
+public:
+ G1FullGCCompactionPoints(uint num_workers) : _num_workers(num_workers) {
+ _cps = NEW_C_HEAP_ARRAY(G1FullGCCompactionPoint*, _num_workers, mtGC);
+ for (uint i = 0; i < _num_workers; i++) {
+ _cps[i] = new G1FullGCCompactionPoint();
+ }
+ _serial_compaction_point = new G1FullGCCompactionPoint();
+ }
+ ~G1FullGCCompactionPoints() {
+ for (uint i = 0; i < _num_workers; i++) {
+ delete _cps[i];
+ }
+ FREE_C_HEAP_ARRAY(G1FullGCCompactionPoint*, _cps, mtGC);
+ delete _serial_compaction_point;
+ }
+
+ G1FullGCCompactionPoint* cp_at(uint i) { return _cps[i]; }
+ uint num_workers() { return _num_workers; }
+
+ G1FullGCCompactionPoint* serial_compaction_point() { return _serial_compaction_point; }
+};
+
+size_t G1RePrepareClosure::apply(oop obj) {
+ // We only re-prepare objects forwarded within the current region, so
+ // skip objects that are already forwarded to another region.
+ oop forwarded_to = obj->forwardee();
+
+ if (forwarded_to != NULL && !_current->is_in(forwarded_to)) {
+ return obj->size();
+ }
+
+ // Get size and forward.
+ size_t size = obj->size();
+ _cp->forward(obj, size);
+
+ return size;
+}
+
+bool G1MarkSweep::_parallel_prepare_compact = false;
+bool G1MarkSweep::_parallel_adjust = false;
+
void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp,
bool clear_all_softrefs) {
assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
+ uint active_workers = G1CollectedHeap::heap()->workers()->active_workers();
+
+ if (G1ParallelFullGC) {
+ _parallel_prepare_compact = true;
+ _parallel_adjust = true;
+ }
SharedHeap* sh = SharedHeap::heap();
#ifdef ASSERT
@@ -89,16 +254,20 @@ void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp,
// The marking doesn't preserve the marks of biased objects.
BiasedLocking::preserve_marks();
- mark_sweep_phase1(marked_for_unloading, clear_all_softrefs);
+ {
+ G1FullGCCompactionPoints cps(active_workers);
+
+ mark_sweep_phase1(marked_for_unloading, clear_all_softrefs);
- mark_sweep_phase2();
+ mark_sweep_phase2(&cps);
- // Don't add any more derived pointers during phase3
- COMPILER2_PRESENT(DerivedPointerTable::set_active(false));
+ // Don't add any more derived pointers during phase3
+ COMPILER2_PRESENT(DerivedPointerTable::set_active(false));
- mark_sweep_phase3();
+ mark_sweep_phase3();
- mark_sweep_phase4();
+ mark_sweep_phase4(&cps);
+ }
GenMarkSweep::restore_marks();
BiasedLocking::restore_marks();
@@ -209,7 +378,170 @@ void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading,
}
-void G1MarkSweep::mark_sweep_phase2() {
+class G1ParallelPrepareCompactClosure : public HeapRegionClosure {
+protected:
+ G1CollectedHeap* _g1h;
+ ModRefBarrierSet* _mrbs;
+ G1FullGCCompactionPoint* _cp;
+ GrowableArray<HeapRegion*>* _start_humongous_regions_to_be_freed;
+
+protected:
+ virtual void prepare_for_compaction(HeapRegion* hr, HeapWord* end) {
+ if (_cp->space == NULL) {
+ _cp->space = hr;
+ _cp->threshold = hr->initialize_threshold();
+ }
+ _cp->add(hr);
+ hr->prepare_for_compaction(_cp);
+ // Also clear the part of the card table that will be unused after compaction.
+ _mrbs->clear(MemRegion(hr->compaction_top(), end));
+ }
+
+public:
+ G1ParallelPrepareCompactClosure(G1FullGCCompactionPoint* cp) :
+ _g1h(G1CollectedHeap::heap()),
+ _mrbs(_g1h->g1_barrier_set()),
+ _cp(cp),
+ _start_humongous_regions_to_be_freed(
+ new (ResourceObj::C_HEAP, mtGC) GrowableArray<HeapRegion*>(32, true, mtGC)) {
+ }
+
+ ~G1ParallelPrepareCompactClosure() {
+ delete _start_humongous_regions_to_be_freed;
+ }
+
+ const GrowableArray<HeapRegion*>* start_humongous_regions_to_be_freed() const {
+ return _start_humongous_regions_to_be_freed;
+ }
+
+ bool doHeapRegion(HeapRegion* hr) {
+ if (hr->isHumongous()) {
+ if (hr->startsHumongous()) {
+ oop obj = oop(hr->bottom());
+ if (obj->is_gc_marked()) {
+ obj->forward_to(obj);
+ _cp->add_huge(hr);
+ } else {
+ _start_humongous_regions_to_be_freed->append(hr);
+ }
+ } else {
+ assert(hr->continuesHumongous(), "Invalid humongous.");
+ }
+ } else {
+ prepare_for_compaction(hr, hr->end());
+ }
+ return false;
+ }
+
+ bool freed_regions() {
+ if (_start_humongous_regions_to_be_freed->length() != 0) {
+ return true;
+ }
+
+ if (!_cp->has_region()) {
+ return false;
+ }
+
+ if (_cp->current_region() != _cp->regions()->top()) {
+ return true;
+ }
+
+ return false;
+ }
+};
+
+class G1FullGCPrepareTask : public AbstractGangTask {
+protected:
+ HeapRegionClaimer _hrclaimer;
+ G1FullGCCompactionPoints* _cps;
+ GrowableArray<HeapRegion*>* _all_start_humongous_regions_to_be_freed;
+ HeapRegionSetCount _humongous_regions_removed;
+ bool _freed_regions;
+
+protected:
+ void free_humongous_region(HeapRegion* hr) {
+ FreeRegionList dummy_free_list("Dummy Free List for G1MarkSweep");
+ assert(hr->startsHumongous(),
+ "Only the start of a humongous region should be freed.");
+ hr->set_containing_set(NULL);
+ _humongous_regions_removed.increment(1u, hr->capacity());
+ G1CollectedHeap::heap()->free_humongous_region(hr, &dummy_free_list, false);
+ dummy_free_list.remove_all();
+ }
+
+ 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.
+ HeapRegionSetCount empty_set;
+ G1CollectedHeap::heap()->remove_from_old_sets(empty_set, _humongous_regions_removed);
+ }
+
+public:
+ G1FullGCPrepareTask(G1FullGCCompactionPoints* cps) :
+ AbstractGangTask("G1 Prepare Task"),
+ _hrclaimer(G1CollectedHeap::heap()->workers()->active_workers()),
+ _cps(cps),
+ _all_start_humongous_regions_to_be_freed(
+ new (ResourceObj::C_HEAP, mtGC) GrowableArray<HeapRegion*>(32, true, mtGC)),
+ _humongous_regions_removed(),
+ _freed_regions(false) { }
+
+ virtual ~G1FullGCPrepareTask() {
+ delete _all_start_humongous_regions_to_be_freed;
+ }
+
+ void work(uint worker_id) {
+ Ticks start = Ticks::now();
+ G1ParallelPrepareCompactClosure closure(_cps->cp_at(worker_id));
+ G1CollectedHeap::heap()->heap_region_par_iterate_chunked(&closure, worker_id, &_hrclaimer);
+ {
+ MutexLockerEx mu(FreeHumongousRegions_lock, Mutex::_no_safepoint_check_flag);
+ _all_start_humongous_regions_to_be_freed->appendAll(closure.start_humongous_regions_to_be_freed());
+ if (closure.freed_regions()) {
+ _freed_regions = true;
+ }
+ }
+ }
+
+ void free_humongous_regions() {
+ for (GrowableArrayIterator<HeapRegion*> it = _all_start_humongous_regions_to_be_freed->begin();
+ it != _all_start_humongous_regions_to_be_freed->end();
+ ++it) {
+ free_humongous_region(*it);
+ }
+ update_sets();
+ }
+
+ bool freed_regions() {
+ return _freed_regions;
+ }
+
+ void prepare_serial_compaction() {
+ for (uint i = 0; i < _cps->num_workers(); i++) {
+ G1FullGCCompactionPoint* cp = _cps->cp_at(i);
+ if (cp->has_region()) {
+ _cps->serial_compaction_point()->add(cp->remove_last());
+ }
+ }
+
+ G1FullGCCompactionPoint* cp = _cps->serial_compaction_point();
+ for (GrowableArrayIterator<HeapRegion*> it = cp->regions()->begin(); it != cp->regions()->end(); ++it) {
+ HeapRegion* current = *it;
+ if (!cp->is_initialized()) {
+ // Initialize the compaction point. Nothing more is needed for the first heap region
+ // since it is already prepared for compaction.
+ cp->initialize(current, false);
+ } else {
+ G1RePrepareClosure re_prepare(cp, current);
+ current->set_compaction_top(current->bottom());
+ current->apply_to_marked_objects(&re_prepare);
+ }
+ }
+ cp->update();
+ }
+};
+
+void G1MarkSweep::mark_sweep_phase2(G1FullGCCompactionPoints* cps) {
// Now all live objects are marked, compute the new object addresses.
// It is not required that we traverse spaces in the same order in
@@ -219,9 +551,21 @@ void G1MarkSweep::mark_sweep_phase2() {
GCTraceTime tm("phase 2", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id());
GenMarkSweep::trace("2");
- prepare_compaction();
+ if (!_parallel_prepare_compact) {
+ prepare_compaction();
+ } else {
+ G1FullGCPrepareTask task(cps);
+ FlexibleWorkGang* flexible = G1CollectedHeap::heap()->workers();
+ flexible->run_task(&task);
+ task.free_humongous_regions();
+
+ if (!task.freed_regions()) {
+ task.prepare_serial_compaction();
+ }
+ }
}
+
class G1AdjustPointersClosure: public HeapRegionClosure {
public:
bool doHeapRegion(HeapRegion* r) {
@@ -240,6 +584,25 @@ class G1AdjustPointersClosure: public HeapRegionClosure {
}
};
+class G1FullGCAdjustTask : public AbstractGangTask {
+ HeapRegionClaimer _hrclaimer;
+ G1AdjustPointersClosure _adjust;
+
+public:
+ G1FullGCAdjustTask() :
+ AbstractGangTask("G1 Adjust Task"),
+ _hrclaimer(G1CollectedHeap::heap()->workers()->active_workers()),
+ _adjust() {
+ }
+ virtual ~G1FullGCAdjustTask() { }
+
+ void work(uint worker_id) {
+ Ticks start = Ticks::now();
+ G1AdjustPointersClosure blk;
+ G1CollectedHeap::heap()->heap_region_par_iterate_chunked(&blk, worker_id, &_hrclaimer);
+ }
+};
+
void G1MarkSweep::mark_sweep_phase3() {
G1CollectedHeap* g1h = G1CollectedHeap::heap();
@@ -250,7 +613,8 @@ void G1MarkSweep::mark_sweep_phase3() {
// Need cleared claim bits for the roots processing
ClassLoaderDataGraph::clear_claimed_marks();
- CodeBlobToOopClosure adjust_code_closure(&GenMarkSweep::adjust_pointer_closure, CodeBlobToOopClosure::FixRelocations);
+ CodeBlobToOopClosure adjust_code_closure(&GenMarkSweep::adjust_pointer_closure,
+ CodeBlobToOopClosure::FixRelocations);
{
G1RootProcessor root_processor(g1h);
root_processor.process_all_roots(&GenMarkSweep::adjust_pointer_closure,
@@ -272,13 +636,19 @@ void G1MarkSweep::mark_sweep_phase3() {
GenMarkSweep::adjust_marks();
- G1AdjustPointersClosure blk;
- g1h->heap_region_iterate(&blk);
+ if (!_parallel_adjust) {
+ G1AdjustPointersClosure blk;
+ g1h->heap_region_iterate(&blk);
+ } else {
+ G1FullGCAdjustTask task;
+ FlexibleWorkGang* flexible = G1CollectedHeap::heap()->workers();
+ flexible->run_task(&task);
+ }
}
+
class G1SpaceCompactClosure: public HeapRegionClosure {
public:
- G1SpaceCompactClosure() {}
bool doHeapRegion(HeapRegion* hr) {
if (hr->isHumongous()) {
@@ -298,7 +668,60 @@ public:
}
};
-void G1MarkSweep::mark_sweep_phase4() {
+class G1FullGCCompactTask : public AbstractGangTask {
+ HeapRegionClaimer _hrclaimer;
+ G1FullGCCompactionPoints* _cps;
+
+ void compact_region(HeapRegion* hr) {
+ hr->compact();
+
+ hr->reset_after_compaction();
+ if (hr->used_region().is_empty()) {
+ hr->reset_bot();
+ }
+ }
+
+public:
+ G1FullGCCompactTask(G1FullGCCompactionPoints* cps) :
+ AbstractGangTask("G1 Compact Task"),
+ _hrclaimer(G1CollectedHeap::heap()->workers()->active_workers()),
+ _cps(cps) {
+ }
+ virtual ~G1FullGCCompactTask() { }
+
+ void work(uint worker_id) {
+ Ticks start = Ticks::now();
+ const GrowableArray<HeapRegion*>* compaction_queue = _cps->cp_at(worker_id)->regions();
+ for (GrowableArrayIterator<HeapRegion*> it = compaction_queue->begin();
+ it != compaction_queue->end();
+ ++it) {
+ HeapRegion* hr = *it;
+ compact_region(hr);
+ }
+
+ const GrowableArray<HeapRegion*>* marked_huge_regions = _cps->cp_at(worker_id)->huge_regions();
+ for (GrowableArrayIterator<HeapRegion*> it = marked_huge_regions->begin();
+ it != marked_huge_regions->end();
+ ++it) {
+ HeapRegion* hr = *it;
+ oop obj = oop(hr->bottom());
+ assert(obj->is_gc_marked(), "Must be");
+ obj->init_mark();
+ hr->reset_during_compaction();
+ }
+ }
+
+ void serial_compaction() {
+ const GrowableArray<HeapRegion*>* compaction_queue = _cps->serial_compaction_point()->regions();
+ for (GrowableArrayIterator<HeapRegion*> it = compaction_queue->begin();
+ it != compaction_queue->end();
+ ++it) {
+ compact_region(*it);
+ }
+ }
+};
+
+void G1MarkSweep::mark_sweep_phase4(G1FullGCCompactionPoints* cps) {
// All pointers are now adjusted, move objects accordingly
// The ValidateMarkSweep live oops tracking expects us to traverse spaces
@@ -310,72 +733,100 @@ void G1MarkSweep::mark_sweep_phase4() {
GCTraceTime tm("phase 4", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id());
GenMarkSweep::trace("4");
- G1SpaceCompactClosure blk;
- g1h->heap_region_iterate(&blk);
+ if (!_parallel_prepare_compact) {
+ G1SpaceCompactClosure blk;
+ g1h->heap_region_iterate(&blk);
+ } else {
+ G1FullGCCompactTask task(cps);
+ FlexibleWorkGang* flexible = G1CollectedHeap::heap()->workers();
+ flexible->run_task(&task);
+ if (cps->serial_compaction_point()->has_region()) {
+ task.serial_compaction();
+ }
+ }
}
-void G1MarkSweep::prepare_compaction_work(G1PrepareCompactClosure* blk) {
- G1CollectedHeap* g1h = G1CollectedHeap::heap();
- g1h->heap_region_iterate(blk);
- blk->update_sets();
-}
+class G1PrepareCompactClosure : public HeapRegionClosure {
+protected:
+ G1CollectedHeap* _g1h;
+ ModRefBarrierSet* _mrbs;
+ CompactPoint _cp;
+ HeapRegionSetCount _humongous_regions_removed;
+
+ virtual void prepare_for_compaction(HeapRegion* hr, HeapWord* end) {
+ // If this is the first live region that we came across which we can compact,
+ // initialize the CompactPoint.
+ if (!is_cp_initialized()) {
+ _cp.space = hr;
+ _cp.threshold = hr->initialize_threshold();
+ }
+ prepare_for_compaction_work(&_cp, hr, end);
+ }
-void G1PrepareCompactClosure::free_humongous_region(HeapRegion* hr) {
- HeapWord* end = hr->end();
- FreeRegionList dummy_free_list("Dummy Free List for G1MarkSweep");
+ void prepare_for_compaction_work(CompactPoint* cp, HeapRegion* hr, HeapWord* end) {
+ hr->prepare_for_compaction(cp);
+ // Also clear the part of the card table that will be unused after
+ // compaction.
+ _mrbs->clear(MemRegion(hr->compaction_top(), end));
+ }
- assert(hr->startsHumongous(),
- "Only the start of a humongous region should be freed.");
+ void free_humongous_region(HeapRegion* hr) {
+ HeapWord* end = hr->end();
+ FreeRegionList dummy_free_list("Dummy Free List for G1MarkSweep");
- hr->set_containing_set(NULL);
- _humongous_regions_removed.increment(1u, hr->capacity());
+ assert(hr->startsHumongous(),
+ "Only the start of a humongous region should be freed.");
- _g1h->free_humongous_region(hr, &dummy_free_list, false /* par */);
- prepare_for_compaction(hr, end);
- dummy_free_list.remove_all();
-}
+ hr->set_containing_set(NULL);
+ _humongous_regions_removed.increment(1u, hr->capacity());
-void G1PrepareCompactClosure::prepare_for_compaction(HeapRegion* hr, HeapWord* end) {
- // If this is the first live region that we came across which we can compact,
- // initialize the CompactPoint.
- if (!is_cp_initialized()) {
- _cp.space = hr;
- _cp.threshold = hr->initialize_threshold();
+ _g1h->free_humongous_region(hr, &dummy_free_list, false /* par */);
+ prepare_for_compaction(hr, end);
+ dummy_free_list.remove_all();
}
- prepare_for_compaction_work(&_cp, hr, end);
-}
-
-void G1PrepareCompactClosure::prepare_for_compaction_work(CompactPoint* cp,
- HeapRegion* hr,
- HeapWord* end) {
- hr->prepare_for_compaction(cp);
- // Also clear the part of the card table that will be unused after
- // compaction.
- _mrbs->clear(MemRegion(hr->compaction_top(), end));
-}
-void G1PrepareCompactClosure::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.
- HeapRegionSetCount empty_set;
- _g1h->remove_from_old_sets(empty_set, _humongous_regions_removed);
-}
+ bool is_cp_initialized() const { return _cp.space != NULL; }
-bool G1PrepareCompactClosure::doHeapRegion(HeapRegion* hr) {
- if (hr->isHumongous()) {
- if (hr->startsHumongous()) {
- oop obj = oop(hr->bottom());
- if (obj->is_gc_marked()) {
- obj->forward_to(obj);
- } else {
- free_humongous_region(hr);
+public:
+ G1PrepareCompactClosure() :
+ _g1h(G1CollectedHeap::heap()),
+ _mrbs(_g1h->g1_barrier_set()),
+ _humongous_regions_removed() { }
+ ~G1PrepareCompactClosure() { }
+
+ 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.
+ HeapRegionSetCount empty_set;
+ _g1h->remove_from_old_sets(empty_set, _humongous_regions_removed);
+ }
+ bool doHeapRegion(HeapRegion* hr) {
+ if (hr->isHumongous()) {
+ if (hr->startsHumongous()) {
+ oop obj = oop(hr->bottom());
+ if (obj->is_gc_marked()) {
+ obj->forward_to(obj);
+ } else {
+ free_humongous_region(hr);
+ }
+ } else {
+ assert(hr->continuesHumongous(), "Invalid humongous.");
}
} else {
- assert(hr->continuesHumongous(), "Invalid humongous.");
+ prepare_for_compaction(hr, hr->end());
}
- } else {
- prepare_for_compaction(hr, hr->end());
+ return false;
}
- return false;
+};
+
+void G1MarkSweep::prepare_compaction() {
+ G1PrepareCompactClosure blk;
+ G1MarkSweep::prepare_compaction_work(&blk);
+}
+
+void G1MarkSweep::prepare_compaction_work(G1PrepareCompactClosure* blk) {
+ G1CollectedHeap* g1h = G1CollectedHeap::heap();
+ g1h->heap_region_iterate(blk);
+ blk->update_sets();
}
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.hpp
index cdde980d3..82aa6b63e 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.hpp
@@ -44,6 +44,21 @@ class ReferenceProcessor;
//
// Class unloading will only occur when a full gc is invoked.
class G1PrepareCompactClosure;
+class G1FullGCCompactionPoints;
+class G1FullGCCompactionPoint;
+
+class G1RePrepareClosure : public StackObj {
+ G1FullGCCompactionPoint* _cp;
+ HeapRegion* _current;
+
+ public:
+ G1RePrepareClosure(G1FullGCCompactionPoint* hrcp,
+ HeapRegion* hr) :
+ _cp(hrcp),
+ _current(hr) { }
+
+ size_t apply(oop obj);
+};
class G1MarkSweep : AllStatic {
friend class VM_G1MarkSweep;
@@ -57,43 +72,25 @@ class G1MarkSweep : AllStatic {
static STWGCTimer* gc_timer() { return GenMarkSweep::_gc_timer; }
static SerialOldTracer* gc_tracer() { return GenMarkSweep::_gc_tracer; }
+ private:
+ static bool _parallel_prepare_compact;
+ static bool _parallel_adjust;
+
private:
// Mark live objects
static void mark_sweep_phase1(bool& marked_for_deopt,
bool clear_all_softrefs);
// Calculate new addresses
- static void mark_sweep_phase2();
+ static void mark_sweep_phase2(G1FullGCCompactionPoints* cps);
// Update pointers
static void mark_sweep_phase3();
// Move objects to new positions
- static void mark_sweep_phase4();
+ static void mark_sweep_phase4(G1FullGCCompactionPoints* cps);
static void allocate_stacks();
static void prepare_compaction();
static void prepare_compaction_work(G1PrepareCompactClosure* blk);
};
-class G1PrepareCompactClosure : public HeapRegionClosure {
- protected:
- G1CollectedHeap* _g1h;
- ModRefBarrierSet* _mrbs;
- CompactPoint _cp;
- HeapRegionSetCount _humongous_regions_removed;
-
- virtual void prepare_for_compaction(HeapRegion* hr, HeapWord* end);
- void prepare_for_compaction_work(CompactPoint* cp, HeapRegion* hr, HeapWord* end);
- void free_humongous_region(HeapRegion* hr);
- bool is_cp_initialized() const { return _cp.space != NULL; }
-
- public:
- G1PrepareCompactClosure() :
- _g1h(G1CollectedHeap::heap()),
- _mrbs(_g1h->g1_barrier_set()),
- _humongous_regions_removed() { }
-
- void update_sets();
- bool doHeapRegion(HeapRegion* hr);
-};
-
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1MARKSWEEP_HPP
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep_ext.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep_ext.cpp
deleted file mode 100644
index 006e787be..000000000
--- a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep_ext.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#include "precompiled.hpp"
-#include "gc_implementation/g1/g1MarkSweep.hpp"
-
-void G1MarkSweep::prepare_compaction() {
- G1PrepareCompactClosure blk;
- G1MarkSweep::prepare_compaction_work(&blk);
-}
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp
index 471844444..b214c6b37 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp
@@ -410,12 +410,9 @@ void G1RemSet::scrub(BitMap* region_bm, BitMap* card_bm) {
}
void G1RemSet::scrub_par(BitMap* region_bm, BitMap* card_bm,
- uint worker_num, int claim_val) {
+ uint worker_num, HeapRegionClaimer *hrclaimer) {
ScrubRSClosure scrub_cl(region_bm, card_bm);
- _g1->heap_region_par_iterate_chunked(&scrub_cl,
- worker_num,
- n_workers(),
- claim_val);
+ _g1->heap_region_par_iterate_chunked(&scrub_cl, worker_num, hrclaimer);
}
G1TriggerClosure::G1TriggerClosure() :
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp
index 9839e86c5..4a9b286a6 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp
@@ -131,7 +131,7 @@ public:
// parallel thread id of the current thread, and "claim_val" is the
// value that should be used to claim heap regions.
void scrub_par(BitMap* region_bm, BitMap* card_bm,
- uint worker_num, int claim_val);
+ uint worker_num, HeapRegionClaimer *hrclaimer);
// Refine the card corresponding to "card_ptr".
// If check_for_refs_into_cset is true, a true result is returned
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp
index db7ddeced..ee7f14278 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp
@@ -359,6 +359,9 @@
experimental(uintx, G1UncommitDelay, 50, \
"Starup delay in seconds for periodic uncommit.") \
\
+ product(bool, G1ParallelFullGC, false, \
+ "Enable Parallel Full GC for G1") \
+ \
G1_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG, DECLARE_MANAGEABLE_FLAG, DECLARE_PRODUCT_RW_FLAG)
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
index 131cdeacd..9b9afa335 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
@@ -28,6 +28,7 @@
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
#include "gc_implementation/g1/g1NUMA.hpp"
#include "gc_implementation/g1/g1OopClosures.inline.hpp"
+#include "gc_implementation/g1/g1MarkSweep.hpp"
#include "gc_implementation/g1/heapRegion.inline.hpp"
#include "gc_implementation/g1/heapRegionBounds.inline.hpp"
#include "gc_implementation/g1/heapRegionRemSet.hpp"
@@ -180,7 +181,6 @@ void HeapRegion::hr_clear(bool par, bool clear_space, bool locked) {
} else {
hrrs->clear();
}
- _claimed = InitialClaimValue;
}
zero_marked_bytes();
@@ -284,17 +284,6 @@ void HeapRegion::clear_humongous() {
_humongous_start_region = NULL;
}
-bool HeapRegion::claimHeapRegion(jint claimValue) {
- jint current = _claimed;
- if (current != claimValue) {
- jint res = Atomic::cmpxchg(claimValue, &_claimed, current);
- if (res == current) {
- return true;
- }
- }
- return false;
-}
-
HeapRegion::HeapRegion(uint hrm_index,
G1BlockOffsetSharedArray* sharedOffsetArray,
MemRegion mr) :
@@ -304,7 +293,7 @@ HeapRegion::HeapRegion(uint hrm_index,
_humongous_start_region(NULL),
_in_collection_set(false),
_next_in_special_set(NULL), _orig_end(NULL),
- _claimed(InitialClaimValue), _evacuation_failed(false),
+ _evacuation_failed(false),
_prev_marked_bytes(0), _next_marked_bytes(0), _gc_efficiency(0.0),
_next_young_region(NULL),
_next_dirty_cards_region(NULL), _next(NULL), _prev(NULL),
@@ -327,7 +316,6 @@ void HeapRegion::initialize(MemRegion mr, bool clear_space, bool mangle_space) {
_in_collection_set = false;
_next_in_special_set = NULL;
_orig_end = NULL;
- _claimed = InitialClaimValue;
_evacuation_failed = false;
_prev_marked_bytes = 0;
_next_marked_bytes = 0;
@@ -1184,6 +1172,10 @@ void G1OffsetTableContigSpace::object_iterate(ObjectClosure* blk) {
}
}
+void G1OffsetTableContigSpace::apply_to_marked_objects(G1RePrepareClosure* closure) {
+ SCAN_AND_REPREPARE(closure);
+}
+
#define block_is_always_obj(q) true
void G1OffsetTableContigSpace::prepare_for_compaction(CompactPoint* cp) {
SCAN_AND_FORWARD(cp, top, block_is_always_obj, block_size);
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp
index bc9527a87..5d2415e84 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp
@@ -52,6 +52,7 @@ class HeapRegionRemSetIterator;
class HeapRegion;
class HeapRegionSetBase;
class nmethod;
+class G1RePrepareClosure;
#define HR_FORMAT "%u:(%s)[" PTR_FORMAT "," PTR_FORMAT "," PTR_FORMAT "]"
#define HR_FORMAT_PARAMS(_hr_) \
@@ -152,7 +153,7 @@ class G1OffsetTableContigSpace: public CompactibleSpace {
void object_iterate(ObjectClosure* blk);
void safe_object_iterate(ObjectClosure* blk);
-
+ void apply_to_marked_objects(G1RePrepareClosure* closure);
void set_bottom(HeapWord* value);
void set_end(HeapWord* value);
@@ -255,9 +256,6 @@ class HeapRegion: public G1OffsetTableContigSpace {
HeapRegionSetBase* _containing_set;
#endif // ASSERT
- // For parallel heapRegion traversal.
- jint _claimed;
-
// We use concurrent marking to determine the amount of live data
// in each heap region.
size_t _prev_marked_bytes; // Bytes known to be live via last completed marking.
@@ -281,15 +279,6 @@ class HeapRegion: public G1OffsetTableContigSpace {
// If a collection pause is in progress, this is the top at the start
// of that pause.
- void init_top_at_mark_start() {
- assert(_prev_marked_bytes == 0 &&
- _next_marked_bytes == 0,
- "Must be called after zero_marked_bytes.");
- HeapWord* bot = bottom();
- _prev_top_at_mark_start = bot;
- _next_top_at_mark_start = bot;
- }
-
// Cached attributes used in the collection set policy information
// The RSet length that was added to the total value
@@ -315,6 +304,15 @@ class HeapRegion: public G1OffsetTableContigSpace {
// there's clearing to be done ourselves. We also always mangle the space.
virtual void initialize(MemRegion mr, bool clear_space = false, bool mangle_space = SpaceDecorator::Mangle);
+ void init_top_at_mark_start() {
+ assert(_prev_marked_bytes == 0 &&
+ _next_marked_bytes == 0,
+ "Must be called after zero_marked_bytes.");
+ HeapWord* bot = bottom();
+ _prev_top_at_mark_start = bot;
+ _next_top_at_mark_start = bot;
+ }
+
static int LogOfHRGrainBytes;
static int LogOfHRGrainWords;
@@ -337,20 +335,6 @@ class HeapRegion: public G1OffsetTableContigSpace {
// up once during initialization time.
static void setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size);
- enum ClaimValues {
- InitialClaimValue = 0,
- FinalCountClaimValue = 1,
- NoteEndClaimValue = 2,
- ScrubRemSetClaimValue = 3,
- ParVerifyClaimValue = 4,
- RebuildRSClaimValue = 5,
- ParEvacFailureClaimValue = 6,
- AggregateCountClaimValue = 7,
- VerifyCountClaimValue = 8,
- ParMarkRootClaimValue = 9,
- ParInspectClaimValue = 10
- };
-
// All allocated blocks are occupied by objects in a HeapRegion
bool block_is_obj(const HeapWord* p) const;
@@ -697,12 +681,6 @@ class HeapRegion: public G1OffsetTableContigSpace {
return (HeapWord *) obj >= next_top_at_mark_start();
}
- // For parallel heapRegion traversal.
- bool claimHeapRegion(int claimValue);
- jint claim_value() { return _claimed; }
- // Use this carefully: only when you're sure no one is claiming...
- void set_claim_value(int claimValue) { _claimed = claimValue; }
-
// Returns the "evacuation_failed" property of the region.
bool evacuation_failed() { return _evacuation_failed; }
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp
index 818f66811..56e2d32df 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp
@@ -31,6 +31,36 @@
#include "gc_implementation/g1/concurrentG1Refine.hpp"
#include "memory/allocation.hpp"
+HeapRegionClaimer::HeapRegionClaimer(uint n_workers) :
+ _n_workers(n_workers), _n_regions(G1CollectedHeap::heap()->_hrm._allocated_heapregions_length), _claims(NULL) {
+ uint* new_claims = NEW_C_HEAP_ARRAY(uint, _n_regions, mtGC);
+ memset(new_claims, Unclaimed, sizeof(*_claims) * _n_regions);
+ _claims = new_claims;
+}
+
+HeapRegionClaimer::~HeapRegionClaimer() {
+ if (_claims != NULL) {
+ FREE_C_HEAP_ARRAY(uint, _claims, mtGC);
+ }
+}
+
+uint HeapRegionClaimer::offset_for_worker(uint worker_id) const {
+ assert(worker_id < _n_workers, "Invalid worker_id.");
+ return _n_regions * worker_id / _n_workers;
+}
+
+bool HeapRegionClaimer::is_region_claimed(uint region_index) const {
+ assert(region_index < _n_regions, "Invalid index.");
+ return _claims[region_index] == Claimed;
+}
+
+bool HeapRegionClaimer::claim_region(uint region_index) {
+ assert(region_index < _n_regions, "Invalid index.");
+ uint old_val = Atomic::cmpxchg(Claimed, &_claims[region_index], Unclaimed);
+ return old_val == Unclaimed;
+}
+
+
void HeapRegionManager::initialize(G1RegionToSpaceMapper* heap_storage,
G1RegionToSpaceMapper* prev_bitmap,
G1RegionToSpaceMapper* next_bitmap,
@@ -360,8 +390,8 @@ uint HeapRegionManager::start_region_for_worker(uint worker_i, uint num_workers,
return num_regions * worker_i / num_workers;
}
-void HeapRegionManager::par_iterate(HeapRegionClosure* blk, uint worker_id, uint num_workers, jint claim_value) const {
- const uint start_index = start_region_for_worker(worker_id, num_workers, _allocated_heapregions_length);
+void HeapRegionManager::par_iterate(HeapRegionClosure* blk, uint worker_id, HeapRegionClaimer* hrclaimer) const {
+ const uint start_index = hrclaimer->offset_for_worker(worker_id);
// Every worker will actually look at all regions, skipping over regions that
// are currently not committed.
@@ -378,11 +408,11 @@ void HeapRegionManager::par_iterate(HeapRegionClosure* blk, uint worker_id, uint
// We'll ignore "continues humongous" regions (we'll process them
// when we come across their corresponding "start humongous"
// region) and regions already claimed.
- if (r->claim_value() == claim_value || r->continuesHumongous()) {
+ if (hrclaimer->is_region_claimed(index) || r->continuesHumongous()) {
continue;
}
// OK, try to claim it
- if (!r->claimHeapRegion(claim_value)) {
+ if (!hrclaimer->claim_region(index)) {
continue;
}
// Success!
@@ -402,10 +432,10 @@ void HeapRegionManager::par_iterate(HeapRegionClosure* blk, uint worker_id, uint
assert(chr->humongous_start_region() == r,
err_msg("Must work on humongous continuation of the original start region "
PTR_FORMAT ", but is " PTR_FORMAT, p2i(r), p2i(chr)));
- assert(chr->claim_value() != claim_value,
+ assert(!hrclaimer->is_region_claimed(ch_index),
"Must not have been claimed yet because claiming of humongous continuation first claims the start region");
- bool claim_result = chr->claimHeapRegion(claim_value);
+ bool claim_result = hrclaimer->claim_region(ch_index);
// We should always be able to claim it; no one else should
// be trying to claim this region.
guarantee(claim_result, "We should always be able to claim the continuesHumongous part of the humongous object");
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp
index a06fa4f56..25f3a223f 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp
@@ -39,6 +39,28 @@ class G1HeapRegionTable : public G1BiasedMappedArray<HeapRegion*> {
virtual HeapRegion* default_value() const { return NULL; }
};
+class HeapRegionClaimer : public StackObj {
+ uint _n_workers;
+ uint _n_regions;
+ volatile uint* _claims;
+ static const uint Unclaimed = 0;
+ static const uint Claimed = 1;
+public:
+ HeapRegionClaimer(uint n_workers = 0);
+ ~HeapRegionClaimer();
+ inline void set_workers(uint n_workers) {
+ assert(n_workers > 0, "Need at least one worker.");
+ _n_workers = n_workers;
+ }
+ // Calculate the starting region for given worker so
+ // that they do not all start from the same region.
+ uint offset_for_worker(uint worker_id) const;
+ // Check if region has been claimed with this HRClaimer.
+ bool is_region_claimed(uint region_index) const;
+ // Claim the given region, returns true if successfully claimed.
+ bool claim_region(uint region_index);
+};
+
// This class keeps track of the actual heap memory, auxiliary data
// and its metadata (i.e., HeapRegion instances) and the list of free regions.
//
@@ -68,6 +90,7 @@ class G1HeapRegionTable : public G1BiasedMappedArray<HeapRegion*> {
class HeapRegionManager: public CHeapObj<mtGC> {
friend class VMStructs;
friend class FreeRegionList;
+ friend class HeapRegionClaimer;
G1HeapRegionTable _regions;
@@ -239,7 +262,7 @@ public:
// terminating the iteration early if doHeapRegion() returns true.
void iterate(HeapRegionClosure* blk) const;
- void par_iterate(HeapRegionClosure* blk, uint worker_id, uint no_of_par_workers, jint claim_value) const;
+ void par_iterate(HeapRegionClosure* blk, uint worker_id, HeapRegionClaimer* hrclaimer) const;
// Uncommit up to num_regions_to_remove regions that are completely free.
// Return the actual number of uncommitted regions.
diff --git a/hotspot/src/share/vm/memory/space.cpp b/hotspot/src/share/vm/memory/space.cpp
index 317384f23..ff9d1de55 100644
--- a/hotspot/src/share/vm/memory/space.cpp
+++ b/hotspot/src/share/vm/memory/space.cpp
@@ -386,7 +386,14 @@ HeapWord* CompactibleSpace::forward(oop q, size_t size,
while (size > compaction_max_size) {
// switch to next compaction space
cp->space->set_compaction_top(compact_top);
- cp->space = cp->space->next_compaction_space();
+
+ CompactibleSpace* tmp = cp->next_compaction_space();
+ if (tmp == NULL) {
+ cp->space = cp->space->next_compaction_space();
+ } else {
+ cp->space = tmp;
+ }
+
if (cp->space == NULL) {
cp->gen = GenCollectedHeap::heap()->prev_gen(cp->gen);
assert(cp->gen != NULL, "compaction must succeed");
diff --git a/hotspot/src/share/vm/memory/space.hpp b/hotspot/src/share/vm/memory/space.hpp
index a4c3f9e3d..5b150c46f 100644
--- a/hotspot/src/share/vm/memory/space.hpp
+++ b/hotspot/src/share/vm/memory/space.hpp
@@ -325,7 +325,7 @@ public:
// A structure to represent a point at which objects are being copied
// during compaction.
-class CompactPoint : public StackObj {
+class CompactPoint : public CHeapObj<mtGC> {
public:
Generation* gen;
CompactibleSpace* space;
@@ -333,6 +333,8 @@ public:
CompactPoint(Generation* g = NULL) :
gen(g), space(NULL), threshold(0) {}
+
+ virtual CompactibleSpace* next_compaction_space() { return NULL; }
};
// A space that supports compaction operations. This is usually, but not
@@ -349,7 +351,7 @@ private:
public:
CompactibleSpace() :
- _compaction_top(NULL), _next_compaction_space(NULL) {}
+ _compaction_top(NULL), _next_compaction_space(NULL), _end_of_live(NULL), _first_dead(NULL) {}
virtual void initialize(MemRegion mr, bool clear_space, bool mangle_space);
virtual void clear(bool mangle_space);
diff --git a/hotspot/src/share/vm/memory/space.inline.hpp b/hotspot/src/share/vm/memory/space.inline.hpp
index 007cebd16..f07eedcea 100644
--- a/hotspot/src/share/vm/memory/space.inline.hpp
+++ b/hotspot/src/share/vm/memory/space.inline.hpp
@@ -156,6 +156,67 @@ inline HeapWord* Space::block_start(const void* p) {
cp->space->set_compaction_top(compact_top); \
}
+#define SCAN_AND_REPREPARE(re_prepare) { \
+ HeapWord* q = bottom(); \
+ HeapWord* t = _end_of_live; /* Established by "prepare_for_compaction". */ \
+ \
+ assert(_first_dead <= _end_of_live, "Stands to reason, no?"); \
+ \
+ if (q < t && _first_dead > q && \
+ !oop(q)->is_gc_marked()) { \
+ /* we have a chunk of the space which hasn't moved and we've \
+ * reinitialized the mark word during the previous pass, so we can't \
+ * use is_gc_marked for the traversal. */ \
+ HeapWord* end = _first_dead; \
+ \
+ while (q < end) { \
+ /* I originally tried to conjoin "block_start(q) == q" to the \
+ * assertion below, but that doesn't work, because you can't \
+ * accurately traverse previous objects to get to the current one \
+ * after their pointers have been \
+ * updated, until the actual compaction is done. dld, 4/00 */ \
+ assert(block_is_obj(q), \
+ "should be at block boundaries, and should be looking at objs"); \
+ \
+ /* point all the oops to the new location */ \
+ size_t size = re_prepare->apply(oop(q)); \
+ \
+ q += size; \
+ } \
+ \
+ if (_first_dead == t) { \
+ q = t; \
+ } else { \
+ /* $$$ This is funky. Using this to read the previously written \
+ * LiveRange. See also use below. */ \
+ q = (HeapWord*)oop(_first_dead)->mark()->decode_pointer(); \
+ } \
+ } \
+ \
+ const intx interval = PrefetchScanIntervalInBytes; \
+ \
+ debug_only(HeapWord* prev_q = NULL); \
+ while (q < t) { \
+ /* prefetch beyond q */ \
+ Prefetch::write(q, interval); \
+ if (oop(q)->is_gc_marked()) { \
+ /* q is alive */ \
+ /* point all the oops to the new location */ \
+ size_t size = re_prepare->apply(oop(q)); \
+ debug_only(prev_q = q); \
+ q += size; \
+ } else { \
+ /* q is not a live object, so its mark should point at the next \
+ * live object */ \
+ debug_only(prev_q = q); \
+ q = (HeapWord*) oop(q)->mark()->decode_pointer(); \
+ assert(q > prev_q, "we should be moving forward through memory"); \
+ } \
+ } \
+ \
+ assert(q == t, "just checking"); \
+}
+
#define SCAN_AND_ADJUST_POINTERS(adjust_obj_size) { \
/* adjust all the interior pointers to point at the new locations of objects \
* Used by MarkSweep::mark_sweep_phase3() */ \
diff --git a/hotspot/src/share/vm/runtime/mutexLocker.cpp b/hotspot/src/share/vm/runtime/mutexLocker.cpp
index 2dcda097e..a96ae50eb 100644
--- a/hotspot/src/share/vm/runtime/mutexLocker.cpp
+++ b/hotspot/src/share/vm/runtime/mutexLocker.cpp
@@ -127,6 +127,8 @@ Monitor* Service_lock = NULL;
Monitor* PeriodicTask_lock = NULL;
Monitor* RedefineClasses_lock = NULL;
+Mutex* FreeHumongousRegions_lock = NULL;
+
#ifdef INCLUDE_JFR
Mutex* JfrStacktrace_lock = NULL;
Monitor* JfrMsg_lock = NULL;
@@ -286,6 +288,8 @@ void mutex_init() {
def(PeriodicTask_lock , Monitor, nonleaf+5, true);
def(RedefineClasses_lock , Monitor, nonleaf+5, true);
+ def(FreeHumongousRegions_lock , Mutex , nonleaf, false);
+
#if INCLUDE_JFR
def(JfrMsg_lock , Monitor, leaf, true);
def(JfrBuffer_lock , Mutex, leaf, true);
diff --git a/hotspot/src/share/vm/runtime/mutexLocker.hpp b/hotspot/src/share/vm/runtime/mutexLocker.hpp
index ec642a24e..428c80181 100644
--- a/hotspot/src/share/vm/runtime/mutexLocker.hpp
+++ b/hotspot/src/share/vm/runtime/mutexLocker.hpp
@@ -143,6 +143,8 @@ extern Monitor* Service_lock; // a lock used for service thre
extern Monitor* PeriodicTask_lock; // protects the periodic task structure
extern Monitor* RedefineClasses_lock; // locks classes from parallel redefinition
+extern Mutex* FreeHumongousRegions_lock; // locks humongous regions from freeing in parallel
+
#if INCLUDE_JFR
extern Mutex* JfrStacktrace_lock; // used to guard access to the JFR stacktrace table
extern Monitor* JfrMsg_lock; // protects JFR messaging
diff --git a/hotspot/test/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java b/hotspot/test/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java
index 5b4e69477..d08d9c106 100644
--- a/hotspot/test/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java
+++ b/hotspot/test/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java
@@ -45,7 +45,7 @@ class ObjectWithSomeRefs {
public ObjectWithSomeRefs other4;
}
-class ReclaimRegionFast {
+class ReclaimRegionClearMarkBitsFast {
public static final long MAX_MILLIS_FOR_RUN = 50 * 1000; // The maximum runtime for the actual test.
public static final int M = 1024*1024;
@@ -123,7 +123,7 @@ public class TestEagerReclaimHumongousRegionsClearMarkBits {
"-XX:ConcGCThreads=1", // Want to make marking as slow as possible.
"-XX:+IgnoreUnrecognizedVMOptions", // G1VerifyBitmaps is develop only.
"-XX:+G1VerifyBitmaps",
- ReclaimRegionFast.class.getName());
+ ReclaimRegionClearMarkBitsFast.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0);
}
diff --git a/hotspot/test/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java b/hotspot/test/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java
index d12e25af7..16d410fdc 100644
--- a/hotspot/test/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java
+++ b/hotspot/test/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java
@@ -45,7 +45,7 @@ class RefHolder {
Object ref;
}
-class ReclaimRegionFast {
+class ReclaimRegionWithRefsFast {
public static final int M = 1024*1024;
@@ -93,7 +93,7 @@ public class TestEagerReclaimHumongousRegionsWithRefs {
"-Xmx128M",
"-Xmn16M",
"-XX:+PrintGC",
- ReclaimRegionFast.class.getName());
+ ReclaimRegionWithRefsFast.class.getName());
Pattern p = Pattern.compile("Full GC");
diff --git a/jdk/test/jdk/jfr/event/gc/detailed/ExecuteOOMApp.java b/jdk/test/jdk/jfr/event/gc/detailed/ExecuteOOMApp.java
index 048bbad0..af0f4096 100644
--- a/jdk/test/jdk/jfr/event/gc/detailed/ExecuteOOMApp.java
+++ b/jdk/test/jdk/jfr/event/gc/detailed/ExecuteOOMApp.java
@@ -55,8 +55,8 @@ public class ExecuteOOMApp {
return false;
}
- out.shouldHaveExitValue(0);
System.out.println(out.getOutput());
+ out.shouldHaveExitValue(0);
return true;
}
diff --git a/jdk/test/jdk/jfr/event/gc/detailed/TestG1ConcurrentModeFailureEvent.java b/jdk/test/jdk/jfr/event/gc/detailed/TestG1ConcurrentModeFailureEvent.java
index ab7005500..e551facb2 100644
--- a/jdk/test/jdk/jfr/event/gc/detailed/TestG1ConcurrentModeFailureEvent.java
+++ b/jdk/test/jdk/jfr/event/gc/detailed/TestG1ConcurrentModeFailureEvent.java
@@ -56,23 +56,27 @@ public class TestG1ConcurrentModeFailureEvent {
private final static int BYTES_TO_ALLOCATE = 1024 * 512;
public static void main(String[] args) throws Exception {
- String[] vmFlags = {"-Xmx512m", "-Xms512m", "-XX:MaxTenuringThreshold=0", "-Xloggc:testG1GC.log", "-verbose:gc",
- "-XX:+UseG1GC", "-XX:+UnlockExperimentalVMOptions", "-XX:-UseFastUnorderedTimeStamps"};
-
- if (!ExecuteOOMApp.execute(EVENT_SETTINGS_FILE, JFR_FILE, vmFlags, BYTES_TO_ALLOCATE)) {
- System.out.println("OOM happened in the other thread(not test thread). Skip test.");
- // Skip test, process terminates due to the OOME error in the different thread
- return;
- }
+ String[][] vmFlags = {
+ {"-Xmx512m", "-Xms512m", "-XX:MaxTenuringThreshold=0", "-Xloggc:testG1GC.log", "-verbose:gc",
+ "-XX:+UseG1GC", "-XX:+UnlockExperimentalVMOptions", "-XX:-UseFastUnorderedTimeStamps"},
+ {"-Xmx512m", "-Xms512m", "-XX:MaxTenuringThreshold=0", "-Xloggc:testG1GC.log", "-verbose:gc",
+ "-XX:+UseG1GC", "-XX:+G1ParallelFullGC", "-XX:+UnlockExperimentalVMOptions", "-XX:-UseFastUnorderedTimeStamps"}};
+ for (int i = 0; i < vmFlags.length; i++) {
+ if (!ExecuteOOMApp.execute(EVENT_SETTINGS_FILE, JFR_FILE, vmFlags[i], BYTES_TO_ALLOCATE)) {
+ System.out.println("OOM happened in the other thread(not test thread). Skip test.");
+ // Skip test, process terminates due to the OOME error in the different thread
+ return;
+ }
- Optional<RecordedEvent> event = RecordingFile.readAllEvents(Paths.get(JFR_FILE)).stream().findFirst();
- if (event.isPresent()) {
- Asserts.assertEquals(EVENT_NAME, event.get().getEventType().getName(), "Wrong event type");
- } else {
- // No event received. Check if test did trigger the event.
- boolean isEventTriggered = fileContainsString("testG1GC.log", "concurrent-mark-abort");
- System.out.println("isEventTriggered=" +isEventTriggered);
- Asserts.assertFalse(isEventTriggered, "Event found in log, but not in JFR");
+ Optional<RecordedEvent> event = RecordingFile.readAllEvents(Paths.get(JFR_FILE)).stream().findFirst();
+ if (event.isPresent()) {
+ Asserts.assertEquals(EVENT_NAME, event.get().getEventType().getName(), "Wrong event type");
+ } else {
+ // No event received. Check if test did trigger the event.
+ boolean isEventTriggered = fileContainsString("testG1GC.log", "concurrent-mark-abort");
+ System.out.println("isEventTriggered=" +isEventTriggered);
+ Asserts.assertFalse(isEventTriggered, "Event found in log, but not in JFR");
+ }
}
}
--
2.22.0
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手