jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp

equal deleted inserted replaced

-:33260c27554b
+:917d8673b5ef
 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away
 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list
 #endif // _MSC_VER
-size_t ConcurrentMark::scale_parallel_threads(size_t n_par_threads) {
+uint ConcurrentMark::scale_parallel_threads(uint n_par_threads) {
-return MAX2((n_par_threads + 2) / 4, (size_t)1);
+return MAX2((n_par_threads + 2) / 4, 1U);
 }
 ConcurrentMark::ConcurrentMark(ReservedSpace rs,
 int max_regions) :
 _markBitMap1(rs, MinObjAlignment - 1),
 _markStack(this),
 _regionStack(),
 // _finger set in set_non_marking_state
-_max_task_num(MAX2(ParallelGCThreads, (size_t)1)),
+_max_task_num(MAX2((uint)ParallelGCThreads, 1U)),
 // _active_tasks set in set_non_marking_state
 // _tasks set inside the constructor
 _task_queues(new CMTaskQueueSet((int) _max_task_num)),
 _terminator(ParallelTaskTerminator((int) _max_task_num, _task_queues)),
 _init_times(),
 _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),
 _cleanup_times(),
 _total_counting_time(0.0),
 _total_rs_scrub_time(0.0),
 _parallel_workers(NULL) {
 CMVerboseLevel verbose_level = (CMVerboseLevel) G1MarkingVerboseLevel;
 if (verbose_level < no_verbose) {
 verbose_level = no_verbose;
 }
 } else {
 if (ConcGCThreads > 0) {
 // notice that ConcGCThreads overwrites G1MarkingOverheadPercent
 // if both are set
-_parallel_marking_threads = ConcGCThreads;
+_parallel_marking_threads = (uint) ConcGCThreads;
 _max_parallel_marking_threads = _parallel_marking_threads;
 _sleep_factor             = 0.0;
 _marking_task_overhead    = 1.0;
 } else if (G1MarkingOverheadPercent > 0) {
 // we will calculate the number of parallel marking threads
 overall_cm_overhead / marking_thread_num *
 (double) os::processor_count();
 double sleep_factor =
 (1.0 - marking_task_overhead) / marking_task_overhead;
-_parallel_marking_threads = (size_t) marking_thread_num;
+_parallel_marking_threads = (uint) marking_thread_num;
 _max_parallel_marking_threads = _parallel_marking_threads;
 _sleep_factor             = sleep_factor;
 _marking_task_overhead    = marking_task_overhead;
 } else {
-_parallel_marking_threads = scale_parallel_threads(ParallelGCThreads);
+_parallel_marking_threads = scale_parallel_threads((uint)ParallelGCThreads);
 _max_parallel_marking_threads = _parallel_marking_threads;
 _sleep_factor             = 0.0;
 _marking_task_overhead    = 1.0;
 }
 gclog_or_tty->print_cr("CL Sleep Factor          %1.4lf", cleanup_sleep_factor());
 #endif
 guarantee(parallel_marking_threads() > 0, "peace of mind");
 _parallel_workers = new FlexibleWorkGang("G1 Parallel Marking Threads",
-(int) _max_parallel_marking_threads, false, true);
+_max_parallel_marking_threads, false, true);
 if (_parallel_workers == NULL) {
 vm_exit_during_initialization("Failed necessary allocation.");
 } else {
 _parallel_workers->initialize_workers();
 }
 // we need this to make sure that the flag is on during the evac
 // pause with initial mark piggy-backed
 set_concurrent_marking_in_progress();
 }
-void ConcurrentMark::set_phase(size_t active_tasks, bool concurrent) {
+void ConcurrentMark::set_phase(uint active_tasks, bool concurrent) {
 assert(active_tasks <= _max_task_num, "we should not have more");
 _active_tasks = active_tasks;
 // Need to update the three data structures below according to the
 // number of active threads for this phase.
 private:
 ConcurrentMark*       _cm;
 ConcurrentMarkThread* _cmt;
 public:
-void work(int worker_i) {
+void work(uint worker_id) {
 assert(Thread::current()->is_ConcurrentGC_thread(),
 "this should only be done by a conc GC thread");
 ResourceMark rm;
 double start_vtime = os::elapsedVTime();
 ConcurrentGCThread::stsJoin();
-assert((size_t) worker_i < _cm->active_tasks(), "invariant");
+assert(worker_id < _cm->active_tasks(), "invariant");
-CMTask* the_task = _cm->task(worker_i);
+CMTask* the_task = _cm->task(worker_id);
 the_task->record_start_time();
 if (!_cm->has_aborted()) {
 do {
 double start_vtime_sec = os::elapsedVTime();
 double start_time_sec = os::elapsedTime();
 double end_vtime_sec = os::elapsedVTime();
 double elapsed_vtime_sec = end_vtime_sec - start_vtime_sec;
 double elapsed_time_sec = end_time_sec - start_time_sec;
 _cm->clear_has_overflown();
-bool ret = _cm->do_yield_check(worker_i);
+bool ret = _cm->do_yield_check(worker_id);
 jlong sleep_time_ms;
 if (!_cm->has_aborted() && the_task->has_aborted()) {
 sleep_time_ms =
 (jlong) (elapsed_vtime_sec * _cm->sleep_factor() * 1000.0);
 guarantee(!the_task->has_aborted() || _cm->has_aborted(), "invariant");
 ConcurrentGCThread::stsLeave();
 double end_vtime = os::elapsedVTime();
-_cm->update_accum_task_vtime(worker_i, end_vtime - start_vtime);
+_cm->update_accum_task_vtime(worker_id, end_vtime - start_vtime);
 }
 CMConcurrentMarkingTask(ConcurrentMark* cm,
 ConcurrentMarkThread* cmt) :
 AbstractGangTask("Concurrent Mark"), _cm(cm), _cmt(cmt) { }
 ~CMConcurrentMarkingTask() { }
 };
 // Calculates the number of active workers for a concurrent
 // phase.
-size_t ConcurrentMark::calc_parallel_marking_threads() {
+uint ConcurrentMark::calc_parallel_marking_threads() {
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-size_t n_conc_workers = 0;
+uint n_conc_workers = 0;
 if (!UseDynamicNumberOfGCThreads ||
 (!FLAG_IS_DEFAULT(ConcGCThreads) &&
 !ForceDynamicNumberOfGCThreads)) {
 n_conc_workers = max_parallel_marking_threads();
 } else {
 // _g1h has _n_par_threads
 _parallel_marking_threads = calc_parallel_marking_threads();
 assert(parallel_marking_threads() <= max_parallel_marking_threads(),
 "Maximum number of marking threads exceeded");
-size_t active_workers = MAX2((size_t) 1, parallel_marking_threads());
+uint active_workers = MAX2(1U, parallel_marking_threads());
 // Parallel task terminator is set in "set_phase()"
 set_phase(active_workers, true /* concurrent */);
 CMConcurrentMarkingTask markingTask(this, cmThread());
 class G1ParFinalCountTask: public AbstractGangTask {
 protected:
 G1CollectedHeap* _g1h;
 CMBitMap* _bm;
-size_t _n_workers;
+uint    _n_workers;
 size_t *_live_bytes;
 size_t *_used_bytes;
 BitMap* _region_bm;
 BitMap* _card_bm;
 public:
 ~G1ParFinalCountTask() {
 FREE_C_HEAP_ARRAY(size_t, _live_bytes);
 FREE_C_HEAP_ARRAY(size_t, _used_bytes);
 }
-void work(int i) {
+void work(uint worker_id) {
 CalcLiveObjectsClosure calccl(true /*final*/,
 _bm, _g1h->concurrent_mark(),
 _region_bm, _card_bm);
 calccl.no_yield();
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-_g1h->heap_region_par_iterate_chunked(&calccl, i,
+_g1h->heap_region_par_iterate_chunked(&calccl, worker_id,
 (int) _n_workers,
 HeapRegion::FinalCountClaimValue);
 } else {
 _g1h->heap_region_iterate(&calccl);
 }
 assert(calccl.complete(), "Shouldn't have yielded!");
-assert((size_t) i < _n_workers, "invariant");
+assert(worker_id < _n_workers, "invariant");
-_live_bytes[i] = calccl.tot_live();
+_live_bytes[worker_id] = calccl.tot_live();
-_used_bytes[i] = calccl.tot_used();
+_used_bytes[worker_id] = calccl.tot_used();
 }
 size_t live_bytes()  {
 size_t live_bytes = 0;
-for (size_t i = 0; i < _n_workers; ++i)
+for (uint i = 0; i < _n_workers; ++i)
 live_bytes += _live_bytes[i];
 return live_bytes;
 }
 size_t used_bytes()  {
 size_t used_bytes = 0;
-for (size_t i = 0; i < _n_workers; ++i)
+for (uint i = 0; i < _n_workers; ++i)
 used_bytes += _used_bytes[i];
 return used_bytes;
 }
 };
 G1ParNoteEndTask(G1CollectedHeap* g1h,
 FreeRegionList* cleanup_list) :
 AbstractGangTask("G1 note end"), _g1h(g1h),
 _max_live_bytes(0), _freed_bytes(0), _cleanup_list(cleanup_list) { }
-void work(int i) {
+void work(uint worker_id) {
 double start = os::elapsedTime();
 FreeRegionList local_cleanup_list("Local Cleanup List");
 OldRegionSet old_proxy_set("Local Cleanup Old Proxy Set");
 HumongousRegionSet humongous_proxy_set("Local Cleanup Humongous Proxy Set");
 HRRSCleanupTask hrrs_cleanup_task;
-G1NoteEndOfConcMarkClosure g1_note_end(_g1h, i, &local_cleanup_list,
+G1NoteEndOfConcMarkClosure g1_note_end(_g1h, worker_id, &local_cleanup_list,
 &old_proxy_set,
 &humongous_proxy_set,
 &hrrs_cleanup_task);
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-_g1h->heap_region_par_iterate_chunked(&g1_note_end, i,
+_g1h->heap_region_par_iterate_chunked(&g1_note_end, worker_id,
 _g1h->workers()->active_workers(),
 HeapRegion::NoteEndClaimValue);
 } else {
 _g1h->heap_region_iterate(&g1_note_end);
 }
 HeapRegionRemSet::finish_cleanup_task(&hrrs_cleanup_task);
 }
 double end = os::elapsedTime();
 if (G1PrintParCleanupStats) {
 gclog_or_tty->print("     Worker thread %d [%8.3f..%8.3f = %8.3f ms] "
-"claimed %d regions (tot = %8.3f ms, max = %8.3f ms).\n",
+"claimed %u regions (tot = %8.3f ms, max = %8.3f ms).\n",
-i, start, end, (end-start)*1000.0,
+worker_id, start, end, (end-start)*1000.0,
 g1_note_end.regions_claimed(),
 g1_note_end.claimed_region_time_sec()*1000.0,
 g1_note_end.max_region_time_sec()*1000.0);
 }
 }
 BitMap* region_bm, BitMap* card_bm) :
 AbstractGangTask("G1 ScrubRS"), _g1rs(g1h->g1_rem_set()),
 _region_bm(region_bm), _card_bm(card_bm)
 {}
-void work(int i) {
+void work(uint worker_id) {
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-_g1rs->scrub_par(_region_bm, _card_bm, i,
+_g1rs->scrub_par(_region_bm, _card_bm, worker_id,
 HeapRegion::ScrubRemSetClaimValue);
 } else {
 _g1rs->scrub(_region_bm, _card_bm);
 }
 }
 double start = os::elapsedTime();
 HeapRegionRemSet::reset_for_cleanup_tasks();
-size_t n_workers;
+uint n_workers;
 // Do counting once more with the world stopped for good measure.
 G1ParFinalCountTask g1_par_count_task(g1h, nextMarkBitMap(),
 &_region_bm, &_card_bm);
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 HeapRegion::InitialClaimValue),
 "sanity check");
 g1h->set_par_threads();
 n_workers = g1h->n_par_threads();
-assert(g1h->n_par_threads() == (int) n_workers,
+assert(g1h->n_par_threads() == n_workers,
 "Should not have been reset");
 g1h->workers()->run_task(&g1_par_count_task);
 // Done with the parallel phase so reset to 0.
 g1h->set_par_threads(0);
 G1CollectedHeap* g1h,
 ConcurrentMark* cm) :
 AbstractGangTask("Process reference objects in parallel"),
 _proc_task(proc_task), _g1h(g1h), _cm(cm) { }
-virtual void work(int i) {
+virtual void work(uint worker_id) {
-CMTask* marking_task = _cm->task(i);
+CMTask* marking_task = _cm->task(worker_id);
 G1CMIsAliveClosure g1_is_alive(_g1h);
 G1CMParKeepAliveAndDrainClosure g1_par_keep_alive(_cm, marking_task);
 G1CMParDrainMarkingStackClosure g1_par_drain(_cm, marking_task);
-_proc_task.work(i, g1_is_alive, g1_par_keep_alive, g1_par_drain);
+_proc_task.work(worker_id, g1_is_alive, g1_par_keep_alive, g1_par_drain);
 }
 };
 void G1CMRefProcTaskExecutor::execute(ProcessTask& proc_task) {
 assert(_workers != NULL, "Need parallel worker threads.");
 public:
 G1CMRefEnqueueTaskProxy(EnqueueTask& enq_task) :
 AbstractGangTask("Enqueue reference objects in parallel"),
 _enq_task(enq_task) { }
-virtual void work(int i) {
+virtual void work(uint worker_id) {
-_enq_task.work(i);
+_enq_task.work(worker_id);
 }
 };
 void G1CMRefProcTaskExecutor::execute(EnqueueTask& enq_task) {
 assert(_workers != NULL, "Need parallel worker threads.");
 G1CMDrainMarkingStackClosure
 g1_drain_mark_stack(nextMarkBitMap(), &_markStack, &g1_keep_alive);
 // We use the work gang from the G1CollectedHeap and we utilize all
 // the worker threads.
-int active_workers = g1h->workers() ? g1h->workers()->active_workers() : 1;
+uint active_workers = g1h->workers() ? g1h->workers()->active_workers() : 1U;
-active_workers = MAX2(MIN2(active_workers, (int)_max_task_num), 1);
+active_workers = MAX2(MIN2(active_workers, _max_task_num), 1U);
 G1CMRefProcTaskExecutor par_task_executor(g1h, this,
 g1h->workers(), active_workers);
 if (rp->processing_is_mt()) {
 class CMRemarkTask: public AbstractGangTask {
 private:
 ConcurrentMark *_cm;
 public:
-void work(int worker_i) {
+void work(uint worker_id) {
 // Since all available tasks are actually started, we should
 // only proceed if we're supposed to be actived.
-if ((size_t)worker_i < _cm->active_tasks()) {
+if (worker_id < _cm->active_tasks()) {
-CMTask* task = _cm->task(worker_i);
+CMTask* task = _cm->task(worker_id);
 task->record_start_time();
 do {
 task->do_marking_step(1000000000.0 /* something very large */,
 true /* do_stealing    */,
 true /* do_termination */);
 g1h->ensure_parsability(false);
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 G1CollectedHeap::StrongRootsScope srs(g1h);
 // this is remark, so we'll use up all active threads
-int active_workers = g1h->workers()->active_workers();
+uint active_workers = g1h->workers()->active_workers();
 if (active_workers == 0) {
 assert(active_workers > 0, "Should have been set earlier");
-active_workers = ParallelGCThreads;
+active_workers = (uint) ParallelGCThreads;
 g1h->workers()->set_active_workers(active_workers);
 }
 set_phase(active_workers, false /* concurrent */);
 // Leave _parallel_marking_threads at it's
 // value originally calculated in the ConcurrentMark
 g1h->workers()->run_task(&remarkTask);
 g1h->set_par_threads(0);
 } else {
 G1CollectedHeap::StrongRootsScope srs(g1h);
 // this is remark, so we'll use up all available threads
-int active_workers = 1;
+uint active_workers = 1;
 set_phase(active_workers, false /* concurrent */);
 CMRemarkTask remarkTask(this, active_workers);
 // We will start all available threads, even if we decide that the
 // active_workers will be fewer. The extra ones will just bail out
 oop*             _ms;
 jint*            _array_ind_stack;
 int              _ms_size;
 int              _ms_ind;
 int              _array_increment;
-int              _worker_i;
+uint             _worker_id;
 bool push(oop obj, int arr_ind = 0) {
 if (_ms_ind == _ms_size) {
 gclog_or_tty->print_cr("Mark stack is full.");
 return false;
 }
 return true;
 }
 public:
-CSetMarkOopClosure(ConcurrentMark* cm, int ms_size, int worker_i) :
+CSetMarkOopClosure(ConcurrentMark* cm, int ms_size, uint worker_id) :
 _g1h(G1CollectedHeap::heap()),
 _cm(cm),
 _bm(cm->nextMarkBitMap()),
 _ms_size(ms_size), _ms_ind(0),
 _ms(NEW_C_HEAP_ARRAY(oop, ms_size)),
 _array_ind_stack(NEW_C_HEAP_ARRAY(jint, ms_size)),
 _array_increment(MAX2(ms_size/8, 16)),
-_worker_i(worker_i) { }
+_worker_id(worker_id) { }
 ~CSetMarkOopClosure() {
 FREE_C_HEAP_ARRAY(oop, _ms);
 FREE_C_HEAP_ARRAY(jint, _array_ind_stack);
 }
 class CSetMarkBitMapClosure: public BitMapClosure {
 G1CollectedHeap*   _g1h;
 CMBitMap*          _bitMap;
 ConcurrentMark*    _cm;
 CSetMarkOopClosure _oop_cl;
-int                _worker_i;
+uint               _worker_id;
 public:
-CSetMarkBitMapClosure(ConcurrentMark* cm, int ms_size, int worker_i) :
+CSetMarkBitMapClosure(ConcurrentMark* cm, int ms_size, int worker_id) :
 _g1h(G1CollectedHeap::heap()),
 _bitMap(cm->nextMarkBitMap()),
-_oop_cl(cm, ms_size, worker_i),
+_oop_cl(cm, ms_size, worker_id),
-_worker_i(worker_i) { }
+_worker_id(worker_id) { }
 bool do_bit(size_t offset) {
 // convert offset into a HeapWord*
 HeapWord* addr = _bitMap->offsetToHeapWord(offset);
 assert(_bitMap->endWord() && addr < _bitMap->endWord(),
 };
 class CompleteMarkingInCSetHRClosure: public HeapRegionClosure {
 CMBitMap*             _bm;
 CSetMarkBitMapClosure _bit_cl;
-int                   _worker_i;
+uint                  _worker_id;
 enum SomePrivateConstants {
 MSSize = 1000
 };
 public:
-CompleteMarkingInCSetHRClosure(ConcurrentMark* cm, int worker_i) :
+CompleteMarkingInCSetHRClosure(ConcurrentMark* cm, int worker_id) :
 _bm(cm->nextMarkBitMap()),
-_bit_cl(cm, MSSize, worker_i),
+_bit_cl(cm, MSSize, worker_id),
-_worker_i(worker_i) { }
+_worker_id(worker_id) { }
 bool doHeapRegion(HeapRegion* hr) {
 if (hr->claimHeapRegion(HeapRegion::CompleteMarkCSetClaimValue)) {
 // The current worker has successfully claimed the region.
 if (!hr->evacuation_failed()) {
 G1ParCompleteMarkInCSetTask(G1CollectedHeap* g1h,
 ConcurrentMark* cm) :
 AbstractGangTask("Complete Mark in CSet"),
 _g1h(g1h), _cm(cm) { }
-void work(int worker_i) {
+void work(uint worker_id) {
-CompleteMarkingInCSetHRClosure cmplt(_cm, worker_i);
+CompleteMarkingInCSetHRClosure cmplt(_cm, worker_id);
-HeapRegion* hr = _g1h->start_cset_region_for_worker(worker_i);
+HeapRegion* hr = _g1h->start_cset_region_for_worker(worker_id);
 _g1h->collection_set_iterate_from(hr, &cmplt);
 }
 };
 void ConcurrentMark::complete_marking_in_collection_set() {
 // This closure is used to mark refs into the CMS generation in
 // the CMS bit map. Called at the first checkpoint.
 // We take a break if someone is trying to stop the world.
-bool ConcurrentMark::do_yield_check(int worker_i) {
+bool ConcurrentMark::do_yield_check(uint worker_id) {
 if (should_yield()) {
-if (worker_i == 0) {
+if (worker_id == 0) {
 _g1h->g1_policy()->record_concurrent_pause();
 }
 cmThread()->yield();
-if (worker_i == 0) {
+if (worker_id == 0) {
 _g1h->g1_policy()->record_concurrent_pause_end();
 }
 return true;
 } else {
 return false;

changeset 11396	917d8673b5ef
parent 11250	ef1ab0772513
child 11403	2a7f52ac7ce3