--- a/src/hotspot/share/gc/cms/compactibleFreeListSpace.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/cms/compactibleFreeListSpace.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -320,7 +320,12 @@
// Constructor
CompactibleFreeListSpace::CompactibleFreeListSpace(BlockOffsetSharedArray* bs, MemRegion mr) :
+ _rescan_task_size(CardTable::card_size_in_words * BitsPerWord *
+ CMSRescanMultiple),
+ _marking_task_size(CardTable::card_size_in_words * BitsPerWord *
+ CMSConcMarkMultiple),
_bt(bs, mr),
+ _collector(NULL),
// free list locks are in the range of values taken by _lockRank
// This range currently is [_leaf+2, _leaf+3]
// Note: this requires that CFLspace c'tors
@@ -328,15 +333,10 @@
// are acquired in the program text. This is true today.
_freelistLock(_lockRank--, "CompactibleFreeListSpace._lock", true,
Monitor::_safepoint_check_sometimes),
+ _preconsumptionDirtyCardClosure(NULL),
_parDictionaryAllocLock(Mutex::leaf - 1, // == rank(ExpandHeap_lock) - 1
"CompactibleFreeListSpace._dict_par_lock", true,
- Monitor::_safepoint_check_never),
- _rescan_task_size(CardTable::card_size_in_words * BitsPerWord *
- CMSRescanMultiple),
- _marking_task_size(CardTable::card_size_in_words * BitsPerWord *
- CMSConcMarkMultiple),
- _collector(NULL),
- _preconsumptionDirtyCardClosure(NULL)
+ Monitor::_safepoint_check_never)
{
assert(sizeof(FreeChunk) / BytesPerWord <= MinChunkSize,
"FreeChunk is larger than expected");
--- a/src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -449,57 +449,57 @@
CMSCollector::CMSCollector(ConcurrentMarkSweepGeneration* cmsGen,
CardTableRS* ct,
ConcurrentMarkSweepPolicy* cp):
+ _overflow_list(NULL),
+ _conc_workers(NULL), // may be set later
+ _completed_initialization(false),
+ _collection_count_start(0),
+ _should_unload_classes(CMSClassUnloadingEnabled),
+ _concurrent_cycles_since_last_unload(0),
+ _roots_scanning_options(GenCollectedHeap::SO_None),
+ _verification_mark_bm(0, Mutex::leaf + 1, "CMS_verification_mark_bm_lock"),
+ _verifying(false),
+ _collector_policy(cp),
+ _inter_sweep_estimate(CMS_SweepWeight, CMS_SweepPadding),
+ _intra_sweep_estimate(CMS_SweepWeight, CMS_SweepPadding),
+ _gc_tracer_cm(new (ResourceObj::C_HEAP, mtGC) CMSTracer()),
+ _gc_timer_cm(new (ResourceObj::C_HEAP, mtGC) ConcurrentGCTimer()),
+ _cms_start_registered(false),
_cmsGen(cmsGen),
// Adjust span to cover old (cms) gen
_span(cmsGen->reserved()),
_ct(ct),
- _span_based_discoverer(_span),
- _ref_processor(NULL), // will be set later
- _conc_workers(NULL), // may be set later
- _abort_preclean(false),
- _start_sampling(false),
- _between_prologue_and_epilogue(false),
_markBitMap(0, Mutex::leaf + 1, "CMS_markBitMap_lock"),
_modUnionTable((CardTable::card_shift - LogHeapWordSize),
-1 /* lock-free */, "No_lock" /* dummy */),
- _modUnionClosurePar(&_modUnionTable),
+ _restart_addr(NULL),
+ _ser_pmc_preclean_ovflw(0),
+ _ser_pmc_remark_ovflw(0),
+ _par_pmc_remark_ovflw(0),
+ _ser_kac_preclean_ovflw(0),
+ _ser_kac_ovflw(0),
+ _par_kac_ovflw(0),
+#ifndef PRODUCT
+ _num_par_pushes(0),
+#endif
+ _span_based_discoverer(_span),
+ _ref_processor(NULL), // will be set later
// Construct the is_alive_closure with _span & markBitMap
_is_alive_closure(_span, &_markBitMap),
- _restart_addr(NULL),
- _overflow_list(NULL),
+ _modUnionClosurePar(&_modUnionTable),
+ _between_prologue_and_epilogue(false),
+ _abort_preclean(false),
+ _start_sampling(false),
_stats(cmsGen),
_eden_chunk_lock(new Mutex(Mutex::leaf + 1, "CMS_eden_chunk_lock", true,
//verify that this lock should be acquired with safepoint check.
Monitor::_safepoint_check_sometimes)),
_eden_chunk_array(NULL), // may be set in ctor body
+ _eden_chunk_index(0), // -- ditto --
_eden_chunk_capacity(0), // -- ditto --
- _eden_chunk_index(0), // -- ditto --
- _survivor_plab_array(NULL), // -- ditto --
_survivor_chunk_array(NULL), // -- ditto --
- _survivor_chunk_capacity(0), // -- ditto --
_survivor_chunk_index(0), // -- ditto --
- _ser_pmc_preclean_ovflw(0),
- _ser_kac_preclean_ovflw(0),
- _ser_pmc_remark_ovflw(0),
- _par_pmc_remark_ovflw(0),
- _ser_kac_ovflw(0),
- _par_kac_ovflw(0),
-#ifndef PRODUCT
- _num_par_pushes(0),
-#endif
- _collection_count_start(0),
- _verifying(false),
- _verification_mark_bm(0, Mutex::leaf + 1, "CMS_verification_mark_bm_lock"),
- _completed_initialization(false),
- _collector_policy(cp),
- _should_unload_classes(CMSClassUnloadingEnabled),
- _concurrent_cycles_since_last_unload(0),
- _roots_scanning_options(GenCollectedHeap::SO_None),
- _inter_sweep_estimate(CMS_SweepWeight, CMS_SweepPadding),
- _intra_sweep_estimate(CMS_SweepWeight, CMS_SweepPadding),
- _gc_tracer_cm(new (ResourceObj::C_HEAP, mtGC) CMSTracer()),
- _gc_timer_cm(new (ResourceObj::C_HEAP, mtGC) ConcurrentGCTimer()),
- _cms_start_registered(false)
+ _survivor_chunk_capacity(0), // -- ditto --
+ _survivor_plab_array(NULL) // -- ditto --
{
// Now expand the span and allocate the collection support structures
// (MUT, marking bit map etc.) to cover both generations subject to
@@ -3037,11 +3037,12 @@
OopTaskQueueSet* task_queues):
YieldingFlexibleGangTask("Concurrent marking done multi-threaded"),
_collector(collector),
+ _n_workers(0),
+ _result(true),
_cms_space(cms_space),
- _n_workers(0), _result(true),
+ _bit_map_lock(collector->bitMapLock()),
_task_queues(task_queues),
- _term(_n_workers, task_queues, _collector),
- _bit_map_lock(collector->bitMapLock())
+ _term(_n_workers, task_queues, _collector)
{
_requested_size = _n_workers;
_term.set_task(this);
@@ -3320,9 +3321,9 @@
_collector(collector),
_task(task),
_span(collector->_span),
- _work_queue(work_queue),
_bit_map(bit_map),
- _overflow_stack(overflow_stack)
+ _overflow_stack(overflow_stack),
+ _work_queue(work_queue)
{ }
virtual void do_oop(oop* p);
virtual void do_oop(narrowOop* p);
@@ -5024,8 +5025,10 @@
AbstractGangTaskWOopQueues("Process referents by policy in parallel",
task_queues,
workers->active_workers()),
- _task(task),
- _collector(collector), _span(span), _mark_bit_map(mark_bit_map)
+ _collector(collector),
+ _mark_bit_map(mark_bit_map),
+ _span(span),
+ _task(task)
{
assert(_collector->_span.equals(_span) && !_span.is_empty(),
"Inconsistency in _span");
@@ -5064,8 +5067,8 @@
CMSParKeepAliveClosure::CMSParKeepAliveClosure(CMSCollector* collector,
MemRegion span, CMSBitMap* bit_map, OopTaskQueue* work_queue):
_span(span),
+ _work_queue(work_queue),
_bit_map(bit_map),
- _work_queue(work_queue),
_mark_and_push(collector, span, bit_map, work_queue),
_low_water_mark(MIN2((work_queue->max_elems()/4),
((uint)CMSWorkQueueDrainThreshold * ParallelGCThreads)))
@@ -5602,8 +5605,8 @@
// bit vector itself. That is done by a separate call CMSBitMap::allocate()
// further below.
CMSBitMap::CMSBitMap(int shifter, int mutex_rank, const char* mutex_name):
+ _shifter(shifter),
_bm(),
- _shifter(shifter),
_lock(mutex_rank >= 0 ? new Mutex(mutex_rank, mutex_name, true,
Monitor::_safepoint_check_sometimes) : NULL)
{
@@ -5852,15 +5855,15 @@
CMSCollector* collector,
bool should_yield,
bool concurrent_precleaning):
- _collector(collector),
_span(span),
_bit_map(bit_map),
_mark_stack(mark_stack),
_pushAndMarkClosure(collector, span, rd, bit_map, mod_union_table,
mark_stack, concurrent_precleaning),
+ _collector(collector),
+ _freelistLock(NULL),
_yield(should_yield),
- _concurrent_precleaning(concurrent_precleaning),
- _freelistLock(NULL)
+ _concurrent_precleaning(concurrent_precleaning)
{
// FIXME: Should initialize in base class constructor.
assert(rd != NULL, "ref_discoverer shouldn't be NULL");
@@ -6957,10 +6960,10 @@
_limit(_sp->sweep_limit()),
_freelistLock(_sp->freelistLock()),
_bitMap(bitMap),
- _yield(should_yield),
_inFreeRange(false), // No free range at beginning of sweep
_freeRangeInFreeLists(false), // No free range at beginning of sweep
_lastFreeRangeCoalesced(false),
+ _yield(should_yield),
_freeFinger(g->used_region().start())
{
NOT_PRODUCT(
@@ -7514,15 +7517,14 @@
(!_span.contains(addr) || _bit_map->isMarked(addr));
}
-
CMSKeepAliveClosure::CMSKeepAliveClosure( CMSCollector* collector,
MemRegion span,
CMSBitMap* bit_map, CMSMarkStack* mark_stack,
bool cpc):
_collector(collector),
_span(span),
+ _mark_stack(mark_stack),
_bit_map(bit_map),
- _mark_stack(mark_stack),
_concurrent_precleaning(cpc) {
assert(!_span.is_empty(), "Empty span could spell trouble");
}
@@ -7610,8 +7612,8 @@
OopTaskQueue* work_queue):
_collector(collector),
_span(span),
- _bit_map(bit_map),
- _work_queue(work_queue) { }
+ _work_queue(work_queue),
+ _bit_map(bit_map) { }
void CMSInnerParMarkAndPushClosure::do_oop(oop obj) {
HeapWord* addr = (HeapWord*)obj;
--- a/src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -1452,9 +1452,9 @@
CMSMarkStack* mark_stack,
MarkRefsIntoAndScanClosure* cl):
_space(space),
- _num_dirty_cards(0),
_scan_cl(collector, span, collector->ref_processor(), bit_map,
- mark_stack, cl) { }
+ mark_stack, cl),
+ _num_dirty_cards(0) { }
MarkFromDirtyCardsClosure(CMSCollector* collector,
MemRegion span,
@@ -1463,9 +1463,9 @@
OopTaskQueue* work_queue,
ParMarkRefsIntoAndScanClosure* cl):
_space(space),
- _num_dirty_cards(0),
_scan_cl(collector, span, collector->ref_processor(), bit_map,
- work_queue, cl) { }
+ work_queue, cl),
+ _num_dirty_cards(0) { }
void do_MemRegion(MemRegion mr);
void set_space(CompactibleFreeListSpace* space) { _space = space; }
@@ -1707,8 +1707,8 @@
bool cpc):
_collector(collector),
_span(span),
+ _mark_stack(mark_stack),
_bit_map(bit_map),
- _mark_stack(mark_stack),
_keep_alive(keep_alive),
_concurrent_precleaning(cpc) {
assert(_concurrent_precleaning == _keep_alive->concurrent_precleaning(),
@@ -1732,8 +1732,8 @@
OopTaskQueue* work_queue):
_collector(collector),
_span(span),
+ _work_queue(work_queue),
_bit_map(bit_map),
- _work_queue(work_queue),
_mark_and_push(collector, span, bit_map, work_queue) { }
public:
--- a/src/hotspot/share/gc/cms/parNewGeneration.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/cms/parNewGeneration.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -75,27 +75,28 @@
PreservedMarks* preserved_marks_,
size_t desired_plab_sz_,
ParallelTaskTerminator& term_) :
- _to_space(to_space_),
- _old_gen(old_gen_),
- _young_gen(young_gen_),
- _thread_num(thread_num_),
_work_queue(work_queue_set_->queue(thread_num_)),
- _to_space_full(false),
_overflow_stack(overflow_stacks_ ? overflow_stacks_ + thread_num_ : NULL),
_preserved_marks(preserved_marks_),
- _ageTable(false), // false ==> not the global age table, no perf data.
_to_space_alloc_buffer(desired_plab_sz_),
_to_space_closure(young_gen_, this),
_old_gen_closure(young_gen_, this),
_to_space_root_closure(young_gen_, this),
+ _older_gen_closure(young_gen_, this),
_old_gen_root_closure(young_gen_, this),
- _older_gen_closure(young_gen_, this),
_evacuate_followers(this, &_to_space_closure, &_old_gen_closure,
&_to_space_root_closure, young_gen_, &_old_gen_root_closure,
work_queue_set_, &term_),
_is_alive_closure(young_gen_),
_scan_weak_ref_closure(young_gen_, this),
_keep_alive_closure(&_scan_weak_ref_closure),
+ _to_space(to_space_),
+ _young_gen(young_gen_),
+ _old_gen(old_gen_),
+ _young_old_boundary(NULL),
+ _thread_num(thread_num_),
+ _ageTable(false), // false ==> not the global age table, no perf data.
+ _to_space_full(false),
_strong_roots_time(0.0),
_term_time(0.0)
{
@@ -344,9 +345,9 @@
PreservedMarksSet& preserved_marks_set,
size_t desired_plab_sz,
ParallelTaskTerminator& term)
- : _young_gen(young_gen),
+ : _term(term),
+ _young_gen(young_gen),
_old_gen(old_gen),
- _term(term),
_per_thread_states(NEW_RESOURCE_ARRAY(ParScanThreadState, num_threads)),
_num_threads(num_threads)
{
@@ -529,8 +530,8 @@
_par_scan_state(par_scan_state_),
_to_space_closure(to_space_closure_),
+ _to_space_root_closure(to_space_root_closure_),
_old_gen_closure(old_gen_closure_),
- _to_space_root_closure(to_space_root_closure_),
_old_gen_root_closure(old_gen_root_closure_),
_par_gen(par_gen_),
_task_queues(task_queues_),
@@ -625,9 +626,9 @@
ParNewGeneration::ParNewGeneration(ReservedSpace rs, size_t initial_byte_size)
: DefNewGeneration(rs, initial_byte_size, "PCopy"),
+ _plab_stats("Young", YoungPLABSize, PLABWeight),
_overflow_list(NULL),
- _is_alive_closure(this),
- _plab_stats("Young", YoungPLABSize, PLABWeight)
+ _is_alive_closure(this)
{
NOT_PRODUCT(_overflow_counter = ParGCWorkQueueOverflowInterval;)
NOT_PRODUCT(_num_par_pushes = 0;)
--- a/src/hotspot/share/gc/epsilon/epsilonMemoryPool.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/epsilon/epsilonMemoryPool.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -27,11 +27,11 @@
#include "gc/epsilon/epsilonMemoryPool.hpp"
EpsilonMemoryPool::EpsilonMemoryPool(EpsilonHeap* heap) :
- _heap(heap),
CollectedMemoryPool("Epsilon Heap",
heap->capacity(),
heap->max_capacity(),
- false) {
+ false),
+ _heap(heap) {
assert(UseEpsilonGC, "sanity");
}
--- a/src/hotspot/share/gc/g1/c1/g1BarrierSetC1.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/c1/g1BarrierSetC1.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -42,7 +42,7 @@
// addr (the address of the field to be read) must be a LIR_Address
// pre_val (a temporary register) must be a register;
G1PreBarrierStub(LIR_Opr addr, LIR_Opr pre_val, LIR_PatchCode patch_code, CodeEmitInfo* info) :
- _addr(addr), _pre_val(pre_val), _do_load(true),
+ _do_load(true), _addr(addr), _pre_val(pre_val),
_patch_code(patch_code), _info(info)
{
assert(_pre_val->is_register(), "should be temporary register");
@@ -52,7 +52,7 @@
// Version that _does not_ generate load of the previous value; the
// previous value is assumed to have already been loaded into pre_val.
G1PreBarrierStub(LIR_Opr pre_val) :
- _addr(LIR_OprFact::illegalOpr), _pre_val(pre_val), _do_load(false),
+ _do_load(false), _addr(LIR_OprFact::illegalOpr), _pre_val(pre_val),
_patch_code(lir_patch_none), _info(NULL)
{
assert(_pre_val->is_register(), "should be a register");
--- a/src/hotspot/share/gc/g1/g1AllocRegion.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1AllocRegion.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -251,10 +251,12 @@
G1AllocRegion::G1AllocRegion(const char* name,
bool bot_updates)
- : _name(name), _bot_updates(bot_updates),
- _alloc_region(NULL), _count(0),
- _used_bytes_before(0) { }
-
+ : _alloc_region(NULL),
+ _count(0),
+ _used_bytes_before(0),
+ _bot_updates(bot_updates),
+ _name(name)
+ { }
HeapRegion* MutatorAllocRegion::allocate_new_region(size_t word_size,
bool force) {
--- a/src/hotspot/share/gc/g1/g1Allocator.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1Allocator.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -37,9 +37,10 @@
_g1h(heap),
_survivor_is_full(false),
_old_is_full(false),
- _retained_old_gc_alloc_region(NULL),
+ _mutator_alloc_region(),
_survivor_gc_alloc_region(heap->alloc_buffer_stats(InCSetState::Young)),
- _old_gc_alloc_region(heap->alloc_buffer_stats(InCSetState::Old)) {
+ _old_gc_alloc_region(heap->alloc_buffer_stats(InCSetState::Old)),
+ _retained_old_gc_alloc_region(NULL) {
}
void G1Allocator::init_mutator_alloc_region() {
--- a/src/hotspot/share/gc/g1/g1Allocator.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1Allocator.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -221,6 +221,7 @@
public:
G1ArchiveAllocator(G1CollectedHeap* g1h, bool open) :
+ _open(open),
_g1h(g1h),
_allocation_region(NULL),
_allocated_regions((ResourceObj::set_allocation_type((address) &_allocated_regions,
@@ -229,8 +230,7 @@
_summary_bytes_used(0),
_bottom(NULL),
_top(NULL),
- _max(NULL),
- _open(open) { }
+ _max(NULL) { }
virtual ~G1ArchiveAllocator() {
assert(_allocation_region == NULL, "_allocation_region not NULL");
--- a/src/hotspot/share/gc/g1/g1Analytics.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1Analytics.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -84,12 +84,12 @@
_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
_mixed_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
_cost_per_byte_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
- _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)),
_constant_other_time_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
_young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
_non_young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
_pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)),
_rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)),
+ _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)),
_recent_prev_end_times_for_all_gcs_sec(new TruncatedSeq(NumPrevPausesForHeuristics)),
_recent_avg_pause_time_ratio(0.0),
_last_pause_time_ratio(0.0) {
--- a/src/hotspot/share/gc/g1/g1BlockOffsetTable.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1BlockOffsetTable.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -75,12 +75,12 @@
//////////////////////////////////////////////////////////////////////
G1BlockOffsetTablePart::G1BlockOffsetTablePart(G1BlockOffsetTable* array, G1ContiguousSpace* gsp) :
+ _next_offset_threshold(NULL),
+ _next_offset_index(0),
+ DEBUG_ONLY(_object_can_span(false) COMMA)
_bot(array),
- _space(gsp),
- _next_offset_threshold(NULL),
- _next_offset_index(0)
+ _space(gsp)
{
- debug_only(_object_can_span = false;)
}
// The arguments follow the normal convention of denoting
--- a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -1407,52 +1407,70 @@
_verifier->verify_region_sets_optional();
}
-// Public methods.
-
G1CollectedHeap::G1CollectedHeap(G1CollectorPolicy* collector_policy) :
CollectedHeap(),
_young_gen_sampling_thread(NULL),
+ _workers(NULL),
_collector_policy(collector_policy),
+ _card_table(NULL),
_soft_ref_policy(),
- _card_table(NULL),
_memory_manager("G1 Young Generation", "end of minor GC"),
_full_gc_memory_manager("G1 Old Generation", "end of major GC"),
_eden_pool(NULL),
_survivor_pool(NULL),
_old_pool(NULL),
+ _old_set("Old Set", false /* humongous */, new OldRegionSetMtSafeChecker()),
+ _humongous_set("Master Humongous Set", true /* humongous */, new HumongousRegionSetMtSafeChecker()),
+ _bot(NULL),
+ _listener(),
+ _hrm(),
+ _allocator(NULL),
+ _verifier(NULL),
+ _summary_bytes_used(0),
+ _archive_allocator(NULL),
+ _survivor_evac_stats("Young", YoungPLABSize, PLABWeight),
+ _old_evac_stats("Old", OldPLABSize, PLABWeight),
+ _expand_heap_after_alloc_failure(true),
+ _g1mm(NULL),
+ _humongous_reclaim_candidates(),
+ _has_humongous_reclaim_candidates(false),
+ _hr_printer(),
+ _collector_state(),
+ _old_marking_cycles_started(0),
+ _old_marking_cycles_completed(0),
+ _eden(),
+ _survivor(),
_gc_timer_stw(new (ResourceObj::C_HEAP, mtGC) STWGCTimer()),
_gc_tracer_stw(new (ResourceObj::C_HEAP, mtGC) G1NewTracer()),
_g1_policy(new G1Policy(_gc_timer_stw)),
+ _heap_sizing_policy(NULL),
_collection_set(this, _g1_policy),
+ _hot_card_cache(NULL),
+ _g1_rem_set(NULL),
_dirty_card_queue_set(false),
+ _cm(NULL),
+ _cm_thread(NULL),
+ _cr(NULL),
+ _task_queues(NULL),
+ _evacuation_failed(false),
+ _evacuation_failed_info_array(NULL),
+ _preserved_marks_set(true /* in_c_heap */),
+#ifndef PRODUCT
+ _evacuation_failure_alot_for_current_gc(false),
+ _evacuation_failure_alot_gc_number(0),
+ _evacuation_failure_alot_count(0),
+#endif
_ref_processor_stw(NULL),
_is_alive_closure_stw(this),
_is_subject_to_discovery_stw(this),
_ref_processor_cm(NULL),
_is_alive_closure_cm(this),
_is_subject_to_discovery_cm(this),
- _bot(NULL),
- _hot_card_cache(NULL),
- _g1_rem_set(NULL),
- _cr(NULL),
- _g1mm(NULL),
- _preserved_marks_set(true /* in_c_heap */),
- _old_set("Old Set", false /* humongous */, new OldRegionSetMtSafeChecker()),
- _humongous_set("Master Humongous Set", true /* humongous */, new HumongousRegionSetMtSafeChecker()),
- _humongous_reclaim_candidates(),
- _has_humongous_reclaim_candidates(false),
- _archive_allocator(NULL),
- _summary_bytes_used(0),
- _survivor_evac_stats("Young", YoungPLABSize, PLABWeight),
- _old_evac_stats("Old", OldPLABSize, PLABWeight),
- _expand_heap_after_alloc_failure(true),
- _old_marking_cycles_started(0),
- _old_marking_cycles_completed(0),
_in_cset_fast_test() {
_workers = new WorkGang("GC Thread", ParallelGCThreads,
- /* are_GC_task_threads */true,
- /* are_ConcurrentGC_threads */false);
+ true /* are_GC_task_threads */,
+ false /* are_ConcurrentGC_threads */);
_workers->initialize_workers();
_verifier = new G1HeapVerifier(this);
@@ -3576,10 +3594,10 @@
// The constructor is run in the VMThread.
G1ParallelCleaningTask(BoolObjectClosure* is_alive, uint num_workers, bool unloading_occurred) :
AbstractGangTask("Parallel Cleaning"),
+ _unloading_occurred(unloading_occurred),
_string_symbol_task(is_alive, true, true, G1StringDedup::is_enabled()),
_code_cache_task(num_workers, is_alive, unloading_occurred),
_klass_cleaning_task(),
- _unloading_occurred(unloading_occurred),
_resolved_method_cleaning_task() {
}
@@ -4325,11 +4343,11 @@
public:
G1FreeCollectionSetTask(G1CollectionSet* collection_set, EvacuationInfo* evacuation_info, const size_t* surviving_young_words) :
AbstractGangTask("G1 Free Collection Set"),
+ _collection_set(collection_set),
_cl(evacuation_info, surviving_young_words),
- _collection_set(collection_set),
_surviving_young_words(surviving_young_words),
+ _rs_lengths(0),
_serial_work_claim(0),
- _rs_lengths(0),
_parallel_work_claim(0),
_num_work_items(collection_set->region_length()),
_work_items(NEW_C_HEAP_ARRAY(WorkItem, _num_work_items, mtGC)) {
--- a/src/hotspot/share/gc/g1/g1CollectedHeap.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1CollectedHeap.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -181,9 +181,6 @@
// Start a new incremental collection set for the next pause.
void start_new_collection_set();
- // The number of regions we could create by expansion.
- uint _expansion_regions;
-
// The block offset table for the G1 heap.
G1BlockOffsetTable* _bot;
@@ -1434,9 +1431,9 @@
G1ParScanThreadState* par_scan_state,
RefToScanQueueSet* queues,
ParallelTaskTerminator* terminator)
- : _g1h(g1h), _par_scan_state(par_scan_state),
- _queues(queues), _terminator(terminator),
- _start_term(0.0), _term_time(0.0), _term_attempts(0) {}
+ : _start_term(0.0), _term_time(0.0), _term_attempts(0),
+ _g1h(g1h), _par_scan_state(par_scan_state),
+ _queues(queues), _terminator(terminator) {}
void do_void();
--- a/src/hotspot/share/gc/g1/g1CollectionSet.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1CollectionSet.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -57,12 +57,11 @@
_eden_region_length(0),
_survivor_region_length(0),
_old_region_length(0),
- _bytes_used_before(0),
- _recorded_rs_lengths(0),
_collection_set_regions(NULL),
_collection_set_cur_length(0),
_collection_set_max_length(0),
- // Incremental CSet attributes
+ _bytes_used_before(0),
+ _recorded_rs_lengths(0),
_inc_build_state(Inactive),
_inc_bytes_used_before(0),
_inc_recorded_rs_lengths(0),
--- a/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -625,7 +625,7 @@
G1CMBitMap* _bitmap;
G1ConcurrentMark* _cm;
public:
- G1ClearBitmapHRClosure(G1CMBitMap* bitmap, G1ConcurrentMark* cm) : HeapRegionClosure(), _cm(cm), _bitmap(bitmap) {
+ G1ClearBitmapHRClosure(G1CMBitMap* bitmap, G1ConcurrentMark* cm) : HeapRegionClosure(), _bitmap(bitmap), _cm(cm) {
}
virtual bool do_heap_region(HeapRegion* r) {
@@ -1095,7 +1095,7 @@
public:
G1UpdateRemSetTrackingBeforeRebuild(G1CollectedHeap* g1h, G1ConcurrentMark* cm, G1PrintRegionLivenessInfoClosure* cl) :
- _g1h(g1h), _cm(cm), _num_regions_selected_for_rebuild(0), _cl(cl) { }
+ _g1h(g1h), _cm(cm), _cl(cl), _num_regions_selected_for_rebuild(0) { }
virtual bool do_heap_region(HeapRegion* r) {
update_remset_before_rebuild(r);
@@ -1415,10 +1415,9 @@
bool _is_serial;
public:
G1CMKeepAliveAndDrainClosure(G1ConcurrentMark* cm, G1CMTask* task, bool is_serial) :
- _cm(cm), _task(task), _is_serial(is_serial),
- _ref_counter_limit(G1RefProcDrainInterval) {
+ _cm(cm), _task(task), _ref_counter_limit(G1RefProcDrainInterval),
+ _ref_counter(_ref_counter_limit), _is_serial(is_serial) {
assert(!_is_serial || _task->worker_id() == 0, "only task 0 for serial code");
- _ref_counter = _ref_counter_limit;
}
virtual void do_oop(narrowOop* p) { do_oop_work(p); }
--- a/src/hotspot/share/gc/g1/g1ConcurrentMarkBitMap.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1ConcurrentMarkBitMap.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -42,7 +42,7 @@
G1ConcurrentMark* const _cm;
G1CMTask* const _task;
public:
- G1CMBitMapClosure(G1CMTask *task, G1ConcurrentMark* cm) : _task(task), _cm(cm) { }
+ G1CMBitMapClosure(G1CMTask *task, G1ConcurrentMark* cm) : _cm(cm), _task(task) { }
bool do_addr(HeapWord* const addr);
};
@@ -88,7 +88,7 @@
return mark_distance();
}
- G1CMBitMap() : _covered(), _bm(), _shifter(LogMinObjAlignment), _listener() { _listener.set_bitmap(this); }
+ G1CMBitMap() : _covered(), _shifter(LogMinObjAlignment), _bm(), _listener() { _listener.set_bitmap(this); }
// Initializes the underlying BitMap to cover the given area.
void initialize(MemRegion heap, G1RegionToSpaceMapper* storage);
--- a/src/hotspot/share/gc/g1/g1ConcurrentMarkThread.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1ConcurrentMarkThread.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -74,15 +74,14 @@
};
};
-// The CM thread is created when the G1 garbage collector is used
-
G1ConcurrentMarkThread::G1ConcurrentMarkThread(G1ConcurrentMark* cm) :
ConcurrentGCThread(),
+ _vtime_start(0.0),
+ _vtime_accum(0.0),
+ _vtime_mark_accum(0.0),
_cm(cm),
_state(Idle),
- _phase_manager_stack(),
- _vtime_accum(0.0),
- _vtime_mark_accum(0.0) {
+ _phase_manager_stack() {
set_name("G1 Main Marker");
create_and_start();
--- a/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -34,11 +34,12 @@
G1ConcurrentRefineThread::G1ConcurrentRefineThread(G1ConcurrentRefine* cr, uint worker_id) :
ConcurrentGCThread(),
+ _vtime_start(0.0),
+ _vtime_accum(0.0),
_worker_id(worker_id),
_active(false),
_monitor(NULL),
- _cr(cr),
- _vtime_accum(0.0)
+ _cr(cr)
{
// Each thread has its own monitor. The i-th thread is responsible for signaling
// to thread i+1 if the number of buffers in the queue exceeds a threshold for this
--- a/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1ConcurrentRefineThread.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -41,7 +41,6 @@
double _vtime_start; // Initial virtual time.
double _vtime_accum; // Accumulated virtual time.
uint _worker_id;
- uint _worker_id_offset;
bool _active;
Monitor* _monitor;
--- a/src/hotspot/share/gc/g1/g1EvacFailure.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1EvacFailure.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -46,7 +46,7 @@
public:
UpdateRSetDeferred(DirtyCardQueue* dcq) :
- _g1h(G1CollectedHeap::heap()), _ct(_g1h->card_table()), _dcq(dcq) {}
+ _g1h(G1CollectedHeap::heap()), _dcq(dcq), _ct(_g1h->card_table()) {}
virtual void do_oop(narrowOop* p) { do_oop_work(p); }
virtual void do_oop( oop* p) { do_oop_work(p); }
@@ -203,10 +203,10 @@
RemoveSelfForwardPtrHRClosure(uint worker_id,
HeapRegionClaimer* hrclaimer) :
_g1h(G1CollectedHeap::heap()),
+ _worker_id(worker_id),
+ _hrclaimer(hrclaimer),
_dcq(&_g1h->dirty_card_queue_set()),
- _update_rset_cl(&_dcq),
- _worker_id(worker_id),
- _hrclaimer(hrclaimer) {
+ _update_rset_cl(&_dcq){
}
size_t remove_self_forward_ptr_by_walking_hr(HeapRegion* hr,
--- a/src/hotspot/share/gc/g1/g1FullGCMarker.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1FullGCMarker.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -29,12 +29,14 @@
G1FullGCMarker::G1FullGCMarker(uint worker_id, PreservedMarks* preserved_stack, G1CMBitMap* bitmap) :
_worker_id(worker_id),
+ _bitmap(bitmap),
+ _oop_stack(),
+ _objarray_stack(),
+ _preserved_stack(preserved_stack),
_mark_closure(worker_id, this, G1CollectedHeap::heap()->ref_processor_stw()),
_verify_closure(VerifyOption_G1UseFullMarking),
- _cld_closure(mark_closure()),
_stack_closure(this),
- _preserved_stack(preserved_stack),
- _bitmap(bitmap) {
+ _cld_closure(mark_closure()) {
_oop_stack.initialize();
_objarray_stack.initialize();
}
--- a/src/hotspot/share/gc/g1/g1FullGCMarker.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1FullGCMarker.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -45,7 +45,6 @@
class G1CMBitMap;
class G1FullGCMarker : public CHeapObj<mtGC> {
-private:
uint _worker_id;
// Backing mark bitmap
G1CMBitMap* _bitmap;
--- a/src/hotspot/share/gc/g1/g1FullGCOopClosures.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1FullGCOopClosures.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -39,10 +39,10 @@
G1VerifyOopClosure::G1VerifyOopClosure(VerifyOption option) :
_g1h(G1CollectedHeap::heap()),
+ _failures(false),
_containing_obj(NULL),
_verify_option(option),
- _cc(0),
- _failures(false) {
+ _cc(0) {
}
void G1VerifyOopClosure::print_object(outputStream* out, oop obj) {
--- a/src/hotspot/share/gc/g1/g1FullGCOopClosures.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1FullGCOopClosures.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -61,9 +61,9 @@
public:
G1MarkAndPushClosure(uint worker, G1FullGCMarker* marker, ReferenceDiscoverer* ref) :
+ OopIterateClosure(ref),
_marker(marker),
- _worker_id(worker),
- OopIterateClosure(ref) { }
+ _worker_id(worker) { }
template <class T> inline void do_oop_work(T* p);
virtual void do_oop(oop* p);
--- a/src/hotspot/share/gc/g1/g1FullGCPrepareTask.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1FullGCPrepareTask.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -61,8 +61,8 @@
G1FullGCPrepareTask::G1FullGCPrepareTask(G1FullCollector* collector) :
G1FullGCTask("G1 Prepare Compact Task", collector),
- _hrclaimer(collector->workers()),
- _freed_regions(false) {
+ _freed_regions(false),
+ _hrclaimer(collector->workers()) {
}
void G1FullGCPrepareTask::set_freed_regions() {
--- a/src/hotspot/share/gc/g1/g1FullGCScope.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1FullGCScope.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -36,8 +36,8 @@
_active(),
_cpu_time(),
_soft_refs(clear_soft, _g1h->soft_ref_policy()),
+ _collector_stats(_g1h->g1mm()->full_collection_counters()),
_memory_stats(memory_manager, _g1h->gc_cause()),
- _collector_stats(_g1h->g1mm()->full_collection_counters()),
_heap_transition(_g1h) {
_timer.register_gc_start();
_tracer.report_gc_start(_g1h->gc_cause(), _timer.gc_start());
--- a/src/hotspot/share/gc/g1/g1GCPhaseTimes.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1GCPhaseTimes.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -489,7 +489,7 @@
}
G1GCParPhaseTimesTracker::G1GCParPhaseTimesTracker(G1GCPhaseTimes* phase_times, G1GCPhaseTimes::GCParPhases phase, uint worker_id) :
- _phase_times(phase_times), _phase(phase), _worker_id(worker_id) {
+ _start_time(), _phase(phase), _phase_times(phase_times), _worker_id(worker_id) {
if (_phase_times != NULL) {
_start_time = Ticks::now();
}
--- a/src/hotspot/share/gc/g1/g1HeapVerifier.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1HeapVerifier.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -127,7 +127,7 @@
public:
G1VerifyCodeRootOopClosure(G1CollectedHeap* g1h, OopClosure* root_cl, VerifyOption vo):
- _g1h(g1h), _root_cl(root_cl), _vo(vo), _nm(NULL), _failures(false) {}
+ _g1h(g1h), _root_cl(root_cl), _nm(NULL), _vo(vo), _failures(false) {}
void do_oop(oop* p) { do_oop_work(p); }
void do_oop(narrowOop* p) { do_oop_work(p); }
--- a/src/hotspot/share/gc/g1/g1HotCardCache.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1HotCardCache.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -29,7 +29,10 @@
#include "runtime/atomic.hpp"
G1HotCardCache::G1HotCardCache(G1CollectedHeap *g1h):
- _g1h(g1h), _hot_cache(NULL), _use_cache(false), _card_counts(g1h) {}
+ _g1h(g1h), _use_cache(false), _card_counts(g1h),
+ _hot_cache(NULL), _hot_cache_size(0), _hot_cache_par_chunk_size(0),
+ _hot_cache_idx(0), _hot_cache_par_claimed_idx(0)
+{}
void G1HotCardCache::initialize(G1RegionToSpaceMapper* card_counts_storage) {
if (default_use_cache()) {
--- a/src/hotspot/share/gc/g1/g1IHOPControl.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1IHOPControl.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -32,8 +32,8 @@
G1IHOPControl::G1IHOPControl(double initial_ihop_percent) :
_initial_ihop_percent(initial_ihop_percent),
_target_occupancy(0),
- _last_allocated_bytes(0),
- _last_allocation_time_s(0.0)
+ _last_allocation_time_s(0.0),
+ _last_allocated_bytes(0)
{
assert(_initial_ihop_percent >= 0.0 && _initial_ihop_percent <= 100.0, "Initial IHOP value must be between 0 and 100 but is %.3f", initial_ihop_percent);
}
@@ -86,12 +86,12 @@
size_t heap_reserve_percent,
size_t heap_waste_percent) :
G1IHOPControl(ihop_percent),
+ _heap_reserve_percent(heap_reserve_percent),
+ _heap_waste_percent(heap_waste_percent),
_predictor(predictor),
_marking_times_s(10, 0.95),
_allocation_rate_s(10, 0.95),
- _last_unrestrained_young_size(0),
- _heap_reserve_percent(heap_reserve_percent),
- _heap_waste_percent(heap_waste_percent)
+ _last_unrestrained_young_size(0)
{
}
--- a/src/hotspot/share/gc/g1/g1MemoryPool.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1MemoryPool.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -32,10 +32,11 @@
size_t init_size,
size_t max_size,
bool support_usage_threshold) :
- _g1mm(g1h->g1mm()), CollectedMemoryPool(name,
- init_size,
- max_size,
- support_usage_threshold) {
+ CollectedMemoryPool(name,
+ init_size,
+ max_size,
+ support_usage_threshold),
+ _g1mm(g1h->g1mm()) {
assert(UseG1GC, "sanity");
}
--- a/src/hotspot/share/gc/g1/g1MonitoringSupport.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1MonitoringSupport.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -80,20 +80,24 @@
_incremental_collection_counters(NULL),
_full_collection_counters(NULL),
_conc_collection_counters(NULL),
+ _young_collection_counters(NULL),
_old_collection_counters(NULL),
_old_space_counters(NULL),
- _young_collection_counters(NULL),
_eden_counters(NULL),
_from_counters(NULL),
_to_counters(NULL),
_overall_reserved(0),
- _overall_committed(0), _overall_used(0),
+ _overall_committed(0),
+ _overall_used(0),
_young_region_num(0),
_young_gen_committed(0),
- _eden_committed(0), _eden_used(0),
- _survivor_committed(0), _survivor_used(0),
- _old_committed(0), _old_used(0) {
+ _eden_committed(0),
+ _eden_used(0),
+ _survivor_committed(0),
+ _survivor_used(0),
+ _old_committed(0),
+ _old_used(0) {
_overall_reserved = g1h->max_capacity();
recalculate_sizes();
--- a/src/hotspot/share/gc/g1/g1OopClosures.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1OopClosures.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -162,7 +162,7 @@
public:
G1CLDScanClosure(G1ParCopyHelper* closure,
bool process_only_dirty, bool must_claim)
- : _process_only_dirty(process_only_dirty), _must_claim(must_claim), _closure(closure), _count(0) {}
+ : _closure(closure), _process_only_dirty(process_only_dirty), _must_claim(must_claim), _count(0) {}
void do_cld(ClassLoaderData* cld);
};
--- a/src/hotspot/share/gc/g1/g1PageBasedVirtualSpace.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1PageBasedVirtualSpace.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -34,8 +34,8 @@
#include "utilities/bitMap.inline.hpp"
G1PageBasedVirtualSpace::G1PageBasedVirtualSpace(ReservedSpace rs, size_t used_size, size_t page_size) :
- _low_boundary(NULL), _high_boundary(NULL), _committed(mtGC), _page_size(0), _special(false),
- _dirty(mtGC), _executable(false) {
+ _low_boundary(NULL), _high_boundary(NULL), _tail_size(0), _page_size(0),
+ _committed(mtGC), _dirty(mtGC), _special(false), _executable(false) {
initialize_with_page_size(rs, used_size, page_size);
}
--- a/src/hotspot/share/gc/g1/g1Policy.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1Policy.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -53,21 +53,32 @@
_mmu_tracker(new G1MMUTrackerQueue(GCPauseIntervalMillis / 1000.0, MaxGCPauseMillis / 1000.0)),
_ihop_control(create_ihop_control(&_predictor)),
_policy_counters(new GCPolicyCounters("GarbageFirst", 1, 2)),
+ _full_collection_start_sec(0.0),
+ _collection_pause_end_millis(os::javaTimeNanos() / NANOSECS_PER_MILLISEC),
+ _young_list_target_length(0),
_young_list_fixed_length(0),
+ _young_list_max_length(0),
_short_lived_surv_rate_group(new SurvRateGroup()),
_survivor_surv_rate_group(new SurvRateGroup()),
_reserve_factor((double) G1ReservePercent / 100.0),
_reserve_regions(0),
+ _young_gen_sizer(),
+ _free_regions_at_end_of_collection(0),
+ _max_rs_lengths(0),
_rs_lengths_prediction(0),
+ _pending_cards(0),
_bytes_allocated_in_old_since_last_gc(0),
_initial_mark_to_mixed(),
_collection_set(NULL),
+ _bytes_copied_during_gc(0),
_g1h(NULL),
_phase_times(new G1GCPhaseTimes(gc_timer, ParallelGCThreads)),
+ _mark_remark_start_sec(0),
+ _mark_cleanup_start_sec(0),
_tenuring_threshold(MaxTenuringThreshold),
_max_survivor_regions(0),
- _survivors_age_table(true),
- _collection_pause_end_millis(os::javaTimeNanos() / NANOSECS_PER_MILLISEC) {
+ _survivors_age_table(true)
+{
}
G1Policy::~G1Policy() {
--- a/src/hotspot/share/gc/g1/g1RegionMarkStatsCache.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1RegionMarkStatsCache.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -27,16 +27,17 @@
#include "memory/allocation.inline.hpp"
G1RegionMarkStatsCache::G1RegionMarkStatsCache(G1RegionMarkStats* target, uint max_regions, uint num_cache_entries) :
+ _target(target),
_num_stats(max_regions),
- _target(target),
+ _cache(NULL),
_num_cache_entries(num_cache_entries),
_cache_hits(0),
- _cache_misses(0) {
+ _cache_misses(0),
+ _num_cache_entries_mask(_num_cache_entries - 1) {
guarantee(is_power_of_2(num_cache_entries),
"Number of cache entries must be power of two, but is %u", num_cache_entries);
_cache = NEW_C_HEAP_ARRAY(G1RegionMarkStatsCacheEntry, _num_cache_entries, mtGC);
- _num_cache_entries_mask = _num_cache_entries - 1;
}
G1RegionMarkStatsCache::~G1RegionMarkStatsCache() {
--- a/src/hotspot/share/gc/g1/g1RegionToSpaceMapper.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1RegionToSpaceMapper.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -37,9 +37,9 @@
size_t region_granularity,
size_t commit_factor,
MemoryType type) :
+ _listener(NULL),
_storage(rs, used_size, page_size),
_region_granularity(region_granularity),
- _listener(NULL),
_commit_map(rs.size() * commit_factor / region_granularity, mtGC) {
guarantee(is_power_of_2(page_size), "must be");
guarantee(is_power_of_2(region_granularity), "must be");
--- a/src/hotspot/share/gc/g1/g1RemSet.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1RemSet.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -282,13 +282,13 @@
G1RemSet::G1RemSet(G1CollectedHeap* g1h,
G1CardTable* ct,
G1HotCardCache* hot_card_cache) :
+ _scan_state(new G1RemSetScanState()),
+ _prev_period_summary(),
_g1h(g1h),
- _scan_state(new G1RemSetScanState()),
_num_conc_refined_cards(0),
_ct(ct),
_g1p(_g1h->g1_policy()),
- _hot_card_cache(hot_card_cache),
- _prev_period_summary() {
+ _hot_card_cache(hot_card_cache) {
}
G1RemSet::~G1RemSet() {
@@ -316,8 +316,8 @@
_scan_objs_on_card_cl(scan_obj_on_card),
_scan_state(scan_state),
_worker_i(worker_i),
+ _cards_scanned(0),
_cards_claimed(0),
- _cards_scanned(0),
_cards_skipped(0),
_rem_set_root_scan_time(),
_rem_set_trim_partially_time(),
@@ -976,8 +976,8 @@
uint n_workers,
uint worker_id_offset) :
AbstractGangTask("G1 Rebuild Remembered Set"),
+ _hr_claimer(n_workers),
_cm(cm),
- _hr_claimer(n_workers),
_worker_id_offset(worker_id_offset) {
}
--- a/src/hotspot/share/gc/g1/g1RemSetSummary.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1RemSetSummary.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -247,9 +247,10 @@
HeapRegion* max_code_root_mem_sz_region() const { return _max_code_root_mem_sz_region; }
public:
- HRRSStatsIter() : _all("All"), _young("Young"), _humongous("Humongous"),
- _free("Free"), _old("Old"), _max_code_root_mem_sz_region(NULL), _max_rs_mem_sz_region(NULL),
- _max_rs_mem_sz(0), _max_code_root_mem_sz(0)
+ HRRSStatsIter() : _young("Young"), _humongous("Humongous"),
+ _free("Free"), _old("Old"), _all("All"),
+ _max_rs_mem_sz(0), _max_rs_mem_sz_region(NULL),
+ _max_code_root_mem_sz(0), _max_code_root_mem_sz_region(NULL)
{}
bool do_heap_region(HeapRegion* r) {
--- a/src/hotspot/share/gc/g1/g1RootProcessor.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1RootProcessor.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -72,8 +72,8 @@
_g1h(g1h),
_process_strong_tasks(G1RP_PS_NumElements),
_srs(n_workers),
+ _par_state_string(StringTable::weak_storage()),
_lock(Mutex::leaf, "G1 Root Scanning barrier lock", false, Monitor::_safepoint_check_never),
- _par_state_string(StringTable::weak_storage()),
_n_workers_discovered_strong_classes(0) {}
void G1RootProcessor::evacuate_roots(G1ParScanThreadState* pss, uint worker_i) {
--- a/src/hotspot/share/gc/g1/g1YoungGenSizer.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/g1YoungGenSizer.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -27,8 +27,9 @@
#include "gc/g1/heapRegion.hpp"
#include "logging/log.hpp"
-G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true),
- _min_desired_young_length(0), _max_desired_young_length(0) {
+G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults),
+ _min_desired_young_length(0), _max_desired_young_length(0), _adaptive_size(true) {
+
if (FLAG_IS_CMDLINE(NewRatio)) {
if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) {
log_warning(gc, ergo)("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio");
--- a/src/hotspot/share/gc/g1/heapRegion.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/heapRegion.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -230,16 +230,19 @@
G1BlockOffsetTable* bot,
MemRegion mr) :
G1ContiguousSpace(bot),
+ _rem_set(NULL),
_hrm_index(hrm_index),
+ _type(),
_humongous_start_region(NULL),
_evacuation_failed(false),
- _prev_marked_bytes(0), _next_marked_bytes(0), _gc_efficiency(0.0),
_next(NULL), _prev(NULL),
#ifdef ASSERT
_containing_set(NULL),
-#endif // ASSERT
- _young_index_in_cset(-1), _surv_rate_group(NULL), _age_index(-1),
- _rem_set(NULL), _recorded_rs_length(0), _predicted_elapsed_time_ms(0)
+#endif
+ _prev_marked_bytes(0), _next_marked_bytes(0), _gc_efficiency(0.0),
+ _young_index_in_cset(-1), _surv_rate_group(NULL), _age_index(-1),
+ _prev_top_at_mark_start(NULL), _next_top_at_mark_start(NULL),
+ _recorded_rs_length(0), _predicted_elapsed_time_ms(0)
{
_rem_set = new HeapRegionRemSet(bot, this);
--- a/src/hotspot/share/gc/g1/heapRegionManager.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/heapRegionManager.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -128,10 +128,13 @@
public:
// Empty constructor, we'll initialize it with the initialize() method.
- HeapRegionManager() : _regions(), _heap_mapper(NULL), _num_committed(0),
- _next_bitmap_mapper(NULL), _prev_bitmap_mapper(NULL), _bot_mapper(NULL),
- _allocated_heapregions_length(0), _available_map(mtGC),
- _free_list("Free list", new MasterFreeRegionListMtSafeChecker())
+ HeapRegionManager() :
+ _regions(), _heap_mapper(NULL),
+ _prev_bitmap_mapper(NULL), _next_bitmap_mapper(NULL), _bot_mapper(NULL),
+ _cardtable_mapper(NULL), _card_counts_mapper(NULL),
+ _free_list("Free list", new MasterFreeRegionListMtSafeChecker()),
+ _available_map(mtGC), _num_committed(0),
+ _allocated_heapregions_length(0)
{ }
void initialize(G1RegionToSpaceMapper* heap_storage,
--- a/src/hotspot/share/gc/g1/heapRegionRemSet.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/heapRegionRemSet.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -68,9 +68,10 @@
PerRegionTable(HeapRegion* hr) :
_hr(hr),
+ _bm(HeapRegion::CardsPerRegion, mtGC),
_occupied(0),
- _bm(HeapRegion::CardsPerRegion, mtGC),
- _collision_list_next(NULL), _next(NULL), _prev(NULL)
+ _next(NULL), _prev(NULL),
+ _collision_list_next(NULL)
{}
void add_card_work(CardIdx_t from_card, bool par) {
@@ -240,11 +241,14 @@
OtherRegionsTable::OtherRegionsTable(HeapRegion* hr, Mutex* m) :
_g1h(G1CollectedHeap::heap()),
- _hr(hr), _m(m),
+ _m(m),
+ _hr(hr),
_coarse_map(G1CollectedHeap::heap()->max_regions(), mtGC),
+ _n_coarse_entries(0),
_fine_grain_regions(NULL),
- _first_all_fine_prts(NULL), _last_all_fine_prts(NULL),
- _n_fine_entries(0), _n_coarse_entries(0),
+ _n_fine_entries(0),
+ _first_all_fine_prts(NULL),
+ _last_all_fine_prts(NULL),
_fine_eviction_start(0),
_sparse_table(hr)
{
@@ -621,10 +625,11 @@
HeapRegionRemSet::HeapRegionRemSet(G1BlockOffsetTable* bot,
HeapRegion* hr)
: _bot(bot),
+ _code_roots(),
_m(Mutex::leaf, FormatBuffer<128>("HeapRegionRemSet lock #%u", hr->hrm_index()), true, Monitor::_safepoint_check_never),
- _code_roots(),
- _state(Untracked),
- _other_regions(hr, &_m) {
+ _other_regions(hr, &_m),
+ _state(Untracked)
+{
}
void HeapRegionRemSet::setup_remset_size() {
@@ -716,18 +721,19 @@
HeapRegionRemSetIterator:: HeapRegionRemSetIterator(HeapRegionRemSet* hrrs) :
_hrrs(hrrs),
- _g1h(G1CollectedHeap::heap()),
_coarse_map(&hrrs->_other_regions._coarse_map),
_bot(hrrs->_bot),
+ _g1h(G1CollectedHeap::heap()),
+ _n_yielded_fine(0),
+ _n_yielded_coarse(0),
+ _n_yielded_sparse(0),
_is(Sparse),
+ _cur_region_card_offset(0),
// Set these values so that we increment to the first region.
_coarse_cur_region_index(-1),
_coarse_cur_region_cur_card(HeapRegion::CardsPerRegion-1),
+ _fine_cur_prt(NULL),
_cur_card_in_prt(HeapRegion::CardsPerRegion),
- _fine_cur_prt(NULL),
- _n_yielded_coarse(0),
- _n_yielded_fine(0),
- _n_yielded_sparse(0),
_sparse_iter(&hrrs->_other_regions._sparse_table) {}
bool HeapRegionRemSetIterator::coarse_has_next(size_t& card_index) {
--- a/src/hotspot/share/gc/g1/heapRegionSet.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/heapRegionSet.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -83,9 +83,12 @@
}
HeapRegionSetBase::HeapRegionSetBase(const char* name, bool humongous, bool free, HRSMtSafeChecker* mt_safety_checker)
- : _name(name), _verify_in_progress(false),
- _is_humongous(humongous), _is_free(free), _mt_safety_checker(mt_safety_checker),
- _length(0)
+ : _is_humongous(humongous),
+ _is_free(free),
+ _mt_safety_checker(mt_safety_checker),
+ _length(0),
+ _name(name),
+ _verify_in_progress(false)
{ }
void FreeRegionList::set_unrealistically_long_length(uint len) {
--- a/src/hotspot/share/gc/g1/heapRegionSet.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/heapRegionSet.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -237,8 +237,9 @@
return hr;
}
- FreeRegionListIterator(FreeRegionList* list) : _curr(NULL), _list(list) {
- _curr = list->_head;
+ FreeRegionListIterator(FreeRegionList* list)
+ : _list(list),
+ _curr(list->_head) {
}
};
--- a/src/hotspot/share/gc/g1/ptrQueue.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/ptrQueue.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -92,14 +92,20 @@
PtrQueueSet::PtrQueueSet(bool notify_when_complete) :
_buffer_size(0),
- _max_completed_queue(0),
- _cbl_mon(NULL), _fl_lock(NULL),
- _notify_when_complete(notify_when_complete),
+ _cbl_mon(NULL),
_completed_buffers_head(NULL),
_completed_buffers_tail(NULL),
_n_completed_buffers(0),
- _process_completed_threshold(0), _process_completed(false),
- _buf_free_list(NULL), _buf_free_list_sz(0)
+ _process_completed_threshold(0),
+ _process_completed(false),
+ _fl_lock(NULL),
+ _buf_free_list(NULL),
+ _buf_free_list_sz(0),
+ _fl_owner(NULL),
+ _all_active(false),
+ _notify_when_complete(notify_when_complete),
+ _max_completed_queue(0),
+ _completed_queue_padding(0)
{
_fl_owner = this;
}
--- a/src/hotspot/share/gc/g1/ptrQueue.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/ptrQueue.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -257,7 +257,6 @@
// set, and return completed buffers to the set.
// All these variables are are protected by the TLOQ_CBL_mon. XXX ???
class PtrQueueSet {
-private:
// The size of all buffers in the set.
size_t _buffer_size;
--- a/src/hotspot/share/gc/g1/sparsePRT.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/sparsePRT.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -88,11 +88,15 @@
float RSHashTable::TableOccupancyFactor = 0.5f;
RSHashTable::RSHashTable(size_t capacity) :
- _capacity(capacity), _capacity_mask(capacity-1),
- _occupied_entries(0), _occupied_cards(0),
+ _num_entries(0),
+ _capacity(capacity),
+ _capacity_mask(capacity-1),
+ _occupied_entries(0),
+ _occupied_cards(0),
_entries(NULL),
_buckets(NEW_C_HEAP_ARRAY(int, capacity, mtGC)),
- _free_list(NullEntry), _free_region(0)
+ _free_region(0),
+ _free_list(NullEntry)
{
_num_entries = (capacity * TableOccupancyFactor) + 1;
_entries = (SparsePRTEntry*)NEW_C_HEAP_ARRAY(char, _num_entries * SparsePRTEntry::size(), mtGC);
--- a/src/hotspot/share/gc/g1/survRateGroup.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/survRateGroup.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -31,9 +31,14 @@
#include "memory/allocation.hpp"
SurvRateGroup::SurvRateGroup() :
- _accum_surv_rate_pred(NULL),
- _surv_rate_pred(NULL),
- _stats_arrays_length(0) {
+ _stats_arrays_length(0),
+ _accum_surv_rate_pred(NULL),
+ _last_pred(0.0),
+ _surv_rate_pred(NULL),
+ _all_regions_allocated(0),
+ _region_num(0),
+ _setup_seq_num(0)
+{
reset();
start_adding_regions();
}
--- a/src/hotspot/share/gc/g1/vm_operations_g1.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/vm_operations_g1.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -47,8 +47,8 @@
: VM_CollectForAllocation(word_size, gc_count_before, gc_cause),
_pause_succeeded(false),
_should_initiate_conc_mark(should_initiate_conc_mark),
+ _should_retry_gc(false),
_target_pause_time_ms(target_pause_time_ms),
- _should_retry_gc(false),
_old_marking_cycles_completed_before(0) {
guarantee(target_pause_time_ms > 0.0,
"target_pause_time_ms = %1.6lf should be positive",
--- a/src/hotspot/share/gc/g1/vm_operations_g1.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/g1/vm_operations_g1.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -49,7 +49,7 @@
class VM_G1CollectForAllocation: public VM_CollectForAllocation {
private:
- bool _pause_succeeded;
+ bool _pause_succeeded;
bool _should_initiate_conc_mark;
bool _should_retry_gc;
--- a/src/hotspot/share/gc/parallel/adjoiningVirtualSpaces.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/parallel/adjoiningVirtualSpaces.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -31,8 +31,9 @@
size_t min_low_byte_size,
size_t min_high_byte_size,
size_t alignment) :
+ _high(NULL), _low(NULL),
_reserved_space(rs), _min_low_byte_size(min_low_byte_size),
- _min_high_byte_size(min_high_byte_size), _low(0), _high(0),
+ _min_high_byte_size(min_high_byte_size),
_alignment(alignment) {}
// The maximum byte sizes are for the initial layout of the
--- a/src/hotspot/share/gc/parallel/gcTaskManager.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/parallel/gcTaskManager.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -373,9 +373,9 @@
//
GCTaskManager::GCTaskManager(uint workers) :
_workers(workers),
+ _created_workers(0),
_active_workers(0),
- _idle_workers(0),
- _created_workers(0) {
+ _idle_workers(0) {
initialize();
}
@@ -962,7 +962,7 @@
_wait_helper.notify();
}
-WaitHelper::WaitHelper() : _should_wait(true), _monitor(MonitorSupply::reserve()) {
+WaitHelper::WaitHelper() : _monitor(MonitorSupply::reserve()), _should_wait(true) {
if (TraceGCTaskManager) {
tty->print_cr("[" INTPTR_FORMAT "]"
" WaitHelper::WaitHelper()"
--- a/src/hotspot/share/gc/parallel/mutableNUMASpace.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/parallel/mutableNUMASpace.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -89,7 +89,7 @@
char* last_page_scanned() { return _last_page_scanned; }
void set_last_page_scanned(char* p) { _last_page_scanned = p; }
public:
- LGRPSpace(int l, size_t alignment) : _lgrp_id(l), _last_page_scanned(NULL), _allocation_failed(false) {
+ LGRPSpace(int l, size_t alignment) : _lgrp_id(l), _allocation_failed(false), _last_page_scanned(NULL) {
_space = new MutableSpace(alignment);
_alloc_rate = new AdaptiveWeightedAverage(NUMAChunkResizeWeight);
}
--- a/src/hotspot/share/gc/parallel/mutableSpace.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/parallel/mutableSpace.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -33,7 +33,7 @@
#include "utilities/align.hpp"
#include "utilities/macros.hpp"
-MutableSpace::MutableSpace(size_t alignment): ImmutableSpace(), _top(NULL), _alignment(alignment) {
+MutableSpace::MutableSpace(size_t alignment): ImmutableSpace(), _alignment(alignment), _top(NULL) {
assert(MutableSpace::alignment() % os::vm_page_size() == 0,
"Space should be aligned");
_mangler = new MutableSpaceMangler(this);
--- a/src/hotspot/share/gc/parallel/parMarkBitMap.inline.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/parallel/parMarkBitMap.inline.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -29,7 +29,7 @@
#include "utilities/bitMap.inline.hpp"
inline ParMarkBitMap::ParMarkBitMap():
- _beg_bits(), _end_bits(), _region_start(NULL), _region_size(0), _virtual_space(NULL), _reserved_byte_size(0)
+ _region_start(NULL), _region_size(0), _beg_bits(), _end_bits(), _virtual_space(NULL), _reserved_byte_size(0)
{ }
inline void ParMarkBitMap::clear_range(idx_t beg, idx_t end) {
--- a/src/hotspot/share/gc/parallel/psAdaptiveSizePolicy.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/parallel/psAdaptiveSizePolicy.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -50,10 +50,10 @@
gc_pause_goal_sec,
gc_cost_ratio),
_collection_cost_margin_fraction(AdaptiveSizePolicyCollectionCostMargin / 100.0),
+ _latest_major_mutator_interval_seconds(0),
_space_alignment(space_alignment),
+ _gc_minor_pause_goal_sec(gc_minor_pause_goal_sec),
_live_at_last_full_gc(init_promo_size),
- _gc_minor_pause_goal_sec(gc_minor_pause_goal_sec),
- _latest_major_mutator_interval_seconds(0),
_young_gen_change_for_major_pause_count(0)
{
// Sizing policy statistics
--- a/src/hotspot/share/gc/parallel/psParallelCompact.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/parallel/psParallelCompact.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -2216,7 +2216,7 @@
bool _enabled;
size_t _total_regions;
public:
- FillableRegionLogger() : _next_index(0), _total_regions(0), _enabled(log_develop_is_enabled(Trace, gc, compaction)) { }
+ FillableRegionLogger() : _next_index(0), _enabled(log_develop_is_enabled(Trace, gc, compaction)), _total_regions(0) { }
~FillableRegionLogger() {
log.trace(SIZE_FORMAT " initially fillable regions", _total_regions);
}
--- a/src/hotspot/share/gc/shared/adaptiveSizePolicy.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/adaptiveSizePolicy.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -49,16 +49,16 @@
size_t init_survivor_size,
double gc_pause_goal_sec,
uint gc_cost_ratio) :
+ _throughput_goal(1.0 - double(1.0 / (1.0 + (double) gc_cost_ratio))),
_eden_size(init_eden_size),
_promo_size(init_promo_size),
_survivor_size(init_survivor_size),
- _gc_pause_goal_sec(gc_pause_goal_sec),
- _throughput_goal(1.0 - double(1.0 / (1.0 + (double) gc_cost_ratio))),
_gc_overhead_limit_exceeded(false),
_print_gc_overhead_limit_would_be_exceeded(false),
_gc_overhead_limit_count(0),
_latest_minor_mutator_interval_seconds(0),
_threshold_tolerance_percent(1.0 + ThresholdTolerance/100.0),
+ _gc_pause_goal_sec(gc_pause_goal_sec),
_young_gen_change_for_minor_throughput(0),
_old_gen_change_for_major_throughput(0) {
assert(AdaptiveSizePolicyGCTimeLimitThreshold > 0,
--- a/src/hotspot/share/gc/shared/cardTable.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/cardTable.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -45,15 +45,15 @@
_scanned_concurrently(conc_scan),
_whole_heap(whole_heap),
_guard_index(0),
- _guard_region(),
_last_valid_index(0),
_page_size(os::vm_page_size()),
_byte_map_size(0),
+ _byte_map(NULL),
+ _byte_map_base(NULL),
+ _cur_covered_regions(0),
_covered(NULL),
_committed(NULL),
- _cur_covered_regions(0),
- _byte_map(NULL),
- _byte_map_base(NULL)
+ _guard_region()
{
assert((uintptr_t(_whole_heap.start()) & (card_size - 1)) == 0, "heap must start at card boundary");
assert((uintptr_t(_whole_heap.end()) & (card_size - 1)) == 0, "heap must end at card boundary");
--- a/src/hotspot/share/gc/shared/collectorPolicy.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/collectorPolicy.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -45,11 +45,11 @@
// CollectorPolicy methods
CollectorPolicy::CollectorPolicy() :
- _space_alignment(0),
- _heap_alignment(0),
_initial_heap_byte_size(InitialHeapSize),
_max_heap_byte_size(MaxHeapSize),
- _min_heap_byte_size(Arguments::min_heap_size())
+ _min_heap_byte_size(Arguments::min_heap_size()),
+ _space_alignment(0),
+ _heap_alignment(0)
{}
#ifdef ASSERT
--- a/src/hotspot/share/gc/shared/gcTraceTime.inline.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/gcTraceTime.inline.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -79,14 +79,14 @@
}
inline GCTraceTimeImpl::GCTraceTimeImpl(LogTargetHandle out_start, LogTargetHandle out_stop, const char* title, GCTimer* timer, GCCause::Cause gc_cause, bool log_heap_usage) :
- _enabled(out_stop.is_enabled()),
_out_start(out_start),
_out_stop(out_stop),
+ _enabled(out_stop.is_enabled()),
_start_ticks(),
- _heap_usage_before(SIZE_MAX),
_title(title),
_gc_cause(gc_cause),
- _timer(timer) {
+ _timer(timer),
+ _heap_usage_before(SIZE_MAX) {
time_stamp(_start_ticks);
if (_enabled) {
--- a/src/hotspot/share/gc/shared/gcUtil.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/gcUtil.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -73,8 +73,8 @@
public:
// Input weight must be between 0 and 100
AdaptiveWeightedAverage(unsigned weight, float avg = 0.0) :
- _average(avg), _sample_count(0), _weight(weight), _last_sample(0.0),
- _is_old(false) {
+ _average(avg), _sample_count(0), _weight(weight),
+ _is_old(false), _last_sample(0.0) {
}
void clear() {
--- a/src/hotspot/share/gc/shared/genCollectedHeap.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/genCollectedHeap.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -73,7 +73,6 @@
Generation::Name old,
const char* policy_counters_name) :
CollectedHeap(),
- _rem_set(NULL),
_young_gen_spec(new GenerationSpec(young,
policy->initial_young_size(),
policy->max_young_size(),
@@ -82,11 +81,12 @@
policy->initial_old_size(),
policy->max_old_size(),
policy->gen_alignment())),
+ _rem_set(NULL),
_gen_policy(policy),
_soft_ref_gen_policy(),
_gc_policy_counters(new GCPolicyCounters(policy_counters_name, 2, 2)),
- _process_strong_tasks(new SubTasksDone(GCH_PS_NumElements)),
- _full_collections_completed(0) {
+ _full_collections_completed(0),
+ _process_strong_tasks(new SubTasksDone(GCH_PS_NumElements)) {
}
jint GenCollectedHeap::initialize() {
--- a/src/hotspot/share/gc/shared/generation.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/generation.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -43,8 +43,8 @@
#include "utilities/events.hpp"
Generation::Generation(ReservedSpace rs, size_t initial_size) :
- _ref_processor(NULL),
- _gc_manager(NULL) {
+ _gc_manager(NULL),
+ _ref_processor(NULL) {
if (!_virtual_space.initialize(rs, initial_size)) {
vm_exit_during_initialization("Could not reserve enough space for "
"object heap");
--- a/src/hotspot/share/gc/shared/generationCounters.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/generationCounters.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -56,7 +56,7 @@
// constructor. The need for such an constructor should be eliminated
// when VirtualSpace and PSVirtualSpace are unified.
GenerationCounters()
- : _name_space(NULL), _current_size(NULL), _virtual_space(NULL) {}
+ : _current_size(NULL), _virtual_space(NULL), _name_space(NULL) {}
// This constructor is used for subclasses that do not have a space
// associated with them (e.g, in G1).
--- a/src/hotspot/share/gc/shared/referenceProcessor.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/referenceProcessor.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -104,10 +104,10 @@
_is_subject_to_discovery(is_subject_to_discovery),
_discovering_refs(false),
_enqueuing_is_done(false),
- _is_alive_non_header(is_alive_non_header),
_processing_is_mt(mt_processing),
_next_id(0),
- _adjust_no_of_processing_threads(adjust_no_of_processing_threads)
+ _adjust_no_of_processing_threads(adjust_no_of_processing_threads),
+ _is_alive_non_header(is_alive_non_header)
{
assert(is_subject_to_discovery != NULL, "must be set");
--- a/src/hotspot/share/gc/shared/referenceProcessor.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/referenceProcessor.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -39,7 +39,7 @@
// List of discovered references.
class DiscoveredList {
public:
- DiscoveredList() : _len(0), _compressed_head(0), _oop_head(NULL) { }
+ DiscoveredList() : _oop_head(NULL), _compressed_head(0), _len(0) { }
inline oop head() const;
HeapWord* adr_head() {
return UseCompressedOops ? (HeapWord*)&_compressed_head :
--- a/src/hotspot/share/gc/shared/referenceProcessor.inline.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/referenceProcessor.inline.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -59,14 +59,17 @@
_prev_discovered_addr(refs_list.adr_head()),
_prev_discovered(NULL),
_current_discovered(refs_list.head()),
+ _current_discovered_addr(NULL),
+ _next_discovered(NULL),
+ _referent_addr(NULL),
+ _referent(NULL),
+ _keep_alive(keep_alive),
+ _is_alive(is_alive),
#ifdef ASSERT
_first_seen(refs_list.head()),
#endif
_processed(0),
- _removed(0),
- _next_discovered(NULL),
- _keep_alive(keep_alive),
- _is_alive(is_alive) {
+ _removed(0) {
}
#endif // SHARE_VM_GC_SHARED_REFERENCEPROCESSOR_INLINE_HPP
--- a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -164,7 +164,7 @@
RefProcTotalPhaseTimesTracker::RefProcTotalPhaseTimesTracker(ReferenceProcessor::RefProcPhases phase_number,
ReferenceProcessorPhaseTimes* phase_times,
ReferenceProcessor* rp) :
- _rp(rp), RefProcPhaseTimeBaseTracker(phase_enum_2_phase_string(phase_number), phase_number, phase_times) {
+ RefProcPhaseTimeBaseTracker(phase_enum_2_phase_string(phase_number), phase_number, phase_times), _rp(rp) {
}
RefProcTotalPhaseTimesTracker::~RefProcTotalPhaseTimesTracker() {
@@ -173,7 +173,7 @@
}
ReferenceProcessorPhaseTimes::ReferenceProcessorPhaseTimes(GCTimer* gc_timer, uint max_gc_threads) :
- _gc_timer(gc_timer), _processing_is_mt(false) {
+ _processing_is_mt(false), _gc_timer(gc_timer) {
for (uint i = 0; i < ReferenceProcessor::RefSubPhaseMax; i++) {
_sub_phases_worker_time_sec[i] = new WorkerDataArray<double>(max_gc_threads, SubPhasesParWorkTitle[i]);
--- a/src/hotspot/share/gc/shared/space.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/space.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -289,7 +289,7 @@
DirtyCardToOopClosure(Space* sp, OopIterateClosure* cl,
CardTable::PrecisionStyle precision,
HeapWord* boundary) :
- _sp(sp), _cl(cl), _precision(precision), _boundary(boundary),
+ _cl(cl), _sp(sp), _precision(precision), _boundary(boundary),
_min_done(NULL) {
NOT_PRODUCT(_last_bottom = NULL);
NOT_PRODUCT(_last_explicit_min_done = NULL);
--- a/src/hotspot/share/gc/shared/space.inline.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/space.inline.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -88,7 +88,7 @@
CompactibleSpace* _space;
public:
- DeadSpacer(CompactibleSpace* space) : _space(space), _allowed_deadspace_words(0) {
+ DeadSpacer(CompactibleSpace* space) : _allowed_deadspace_words(0), _space(space) {
size_t ratio = _space->allowed_dead_ratio();
_active = ratio > 0;
--- a/src/hotspot/share/gc/shared/stringdedup/stringDedupTable.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/stringdedup/stringDedupTable.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -224,8 +224,8 @@
StringDedupTable::StringDedupTable(size_t size, jint hash_seed) :
_size(size),
_entries(0),
+ _shrink_threshold((uintx)(size * _shrink_load_factor)),
_grow_threshold((uintx)(size * _grow_load_factor)),
- _shrink_threshold((uintx)(size * _shrink_load_factor)),
_rehash_needed(false),
_hash_seed(hash_seed) {
assert(is_power_of_2(size), "Table size must be a power of 2");
--- a/src/hotspot/share/gc/shared/threadLocalAllocBuffer.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/threadLocalAllocBuffer.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -115,7 +115,7 @@
static GlobalTLABStats* global_stats() { return _global_stats; }
public:
- ThreadLocalAllocBuffer() : _allocation_fraction(TLABAllocationWeight), _allocated_before_last_gc(0) {
+ ThreadLocalAllocBuffer() : _allocated_before_last_gc(0), _allocation_fraction(TLABAllocationWeight) {
// do nothing. tlabs must be inited by initialize() calls
}
--- a/src/hotspot/share/gc/shared/vmGCOperations.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/vmGCOperations.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -186,7 +186,7 @@
uint full_gc_count_before,
GCCause::Cause gc_cause)
: VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true),
- _loader_data(loader_data), _size(size), _mdtype(mdtype), _result(NULL) {
+ _result(NULL), _size(size), _mdtype(mdtype), _loader_data(loader_data) {
assert(_size != 0, "An allocation should always be requested with this operation.");
AllocTracer::send_allocation_requiring_gc_event(_size * HeapWordSize, GCId::peek());
}
@@ -282,7 +282,7 @@
}
VM_CollectForAllocation::VM_CollectForAllocation(size_t word_size, uint gc_count_before, GCCause::Cause cause)
- : VM_GC_Operation(gc_count_before, cause), _result(NULL), _word_size(word_size) {
+ : VM_GC_Operation(gc_count_before, cause), _word_size(word_size), _result(NULL) {
// Only report if operation was really caused by an allocation.
if (_word_size != 0) {
AllocTracer::send_allocation_requiring_gc_event(_word_size * HeapWordSize, GCId::peek());
--- a/src/hotspot/share/gc/shared/workerDataArray.inline.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/workerDataArray.inline.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -31,10 +31,10 @@
template <typename T>
WorkerDataArray<T>::WorkerDataArray(uint length, const char* title) :
- _title(title),
- _length(0) {
+ _data(NULL),
+ _length(length),
+ _title(title) {
assert(length > 0, "Must have some workers to store data for");
- _length = length;
_data = NEW_C_HEAP_ARRAY(T, _length, mtGC);
for (uint i = 0; i < MaxThreadWorkItems; i++) {
_thread_work_items[i] = NULL;
--- a/src/hotspot/share/gc/shared/workgroup.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/workgroup.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -187,12 +187,13 @@
Monitor* _monitor;
public:
- MutexGangTaskDispatcher()
- : _task(NULL),
- _monitor(new Monitor(Monitor::leaf, "WorkGang dispatcher lock", false, Monitor::_safepoint_check_never)),
- _started(0),
- _finished(0),
- _num_workers(0) {}
+ MutexGangTaskDispatcher() :
+ _task(NULL),
+ _started(0),
+ _finished(0),
+ _num_workers(0),
+ _monitor(new Monitor(Monitor::leaf, "WorkGang dispatcher lock", false, Monitor::_safepoint_check_never)) {
+ }
~MutexGangTaskDispatcher() {
delete _monitor;
@@ -408,7 +409,7 @@
// SubTasksDone functions.
SubTasksDone::SubTasksDone(uint n) :
- _n_tasks(n), _tasks(NULL) {
+ _tasks(NULL), _n_tasks(n), _threads_completed(0) {
_tasks = NEW_C_HEAP_ARRAY(uint, n, mtInternal);
guarantee(_tasks != NULL, "alloc failure");
clear();
--- a/src/hotspot/share/gc/shared/workgroup.hpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/shared/workgroup.hpp Wed Aug 08 15:31:06 2018 +0200
@@ -130,10 +130,11 @@
public:
AbstractWorkGang(const char* name, uint workers, bool are_GC_task_threads, bool are_ConcurrentGC_threads) :
- _name(name),
+ _workers(NULL),
_total_workers(workers),
_active_workers(UseDynamicNumberOfGCThreads ? 1U : workers),
_created_workers(0),
+ _name(name),
_are_GC_task_threads(are_GC_task_threads),
_are_ConcurrentGC_threads(are_ConcurrentGC_threads)
{ }
--- a/src/hotspot/share/gc/z/zStat.cpp Wed Aug 08 10:21:23 2018 +0800
+++ b/src/hotspot/share/gc/z/zStat.cpp Wed Aug 08 15:31:06 2018 +0200
@@ -83,8 +83,8 @@
ZStatSamplerHistoryInterval() :
_next(0),
_samples(),
- _total(),
- _accumulated() {}
+ _accumulated(),
+ _total() {}
bool add(const ZStatSamplerData& new_sample) {
// Insert sample