jdk-sandbox: comparison src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp

equal deleted inserted replaced

-:7939b3c4e408
+:c25572739e7c
 bool CMSCollector::_foregroundGCShouldWait = false;
 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),
+_modUnionClosurePar(&_modUnionTable),
-_overflow_list(NULL),
+_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_index(0),    // -- ditto --
 _survivor_chunk_capacity(0), // -- ditto --
-_survivor_chunk_index(0),    // -- ditto --
+_survivor_plab_array(NULL)   // -- 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)
 {
 // Now expand the span and allocate the collection support structures
 // (MUT, marking bit map etc.) to cover both generations subject to
 // collection.
 CompactibleFreeListSpace* cms_space,
 YieldingFlexibleWorkGang* workers,
 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),
+_term(_n_workers, task_queues, _collector)
-_bit_map_lock(collector->bitMapLock())
 {
 _requested_size = _n_workers;
 _term.set_task(this);
 _term_term.set_task(this);
 _restart_addr = _global_finger = _cms_space->bottom();
 CMSBitMap* bit_map, CMSMarkStack* overflow_stack):
 MetadataVisitingOopIterateClosure(collector->ref_processor()),
 _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);
 void trim_queue(size_t max);
 AbstractWorkGang* workers,
 OopTaskQueueSet* task_queues):
 AbstractGangTaskWOopQueues("Process referents by policy in parallel",
 task_queues,
 workers->active_workers()),
-_task(task),
+_collector(collector),
-_collector(collector), _span(span), _mark_bit_map(mark_bit_map)
+_mark_bit_map(mark_bit_map),
+_span(span),
+_task(task)
 {
 assert(_collector->_span.equals(_span) && !_span.is_empty(),
 "Inconsistency in _span");
 }
 }
 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)))
 { }
 // Construct a CMS bit map infrastructure, but don't create the
 // 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)
 {
 _bmStartWord = 0;
 _bmWordSize  = 0;
 CMSBitMap* mod_union_table,
 CMSMarkStack*  mark_stack,
 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),
+_concurrent_precleaning(concurrent_precleaning)
-_freelistLock(NULL)
 {
 // FIXME: Should initialize in base class constructor.
 assert(rd != NULL, "ref_discoverer shouldn't be NULL");
 set_ref_discoverer_internal(rd);
 }
 _g(g),
 _sp(g->cmsSpace()),
 _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(
 _numObjectsFreed = 0;
 _numWordsFreed   = 0;
 HeapWord* addr = (HeapWord*)obj;
 return addr != NULL &&
 (!_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");
 }
 CMSCollector* collector,
 MemRegion span, CMSBitMap* bit_map,
 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;
 if (_span.contains(addr) &&
 !_bit_map->isMarked(addr)) {

changeset 51332	c25572739e7c
parent 51292	0538a5cdb474
child 51598	c88019b32bc4