truffle: src/share/vm/gc_implementation/g1/concurrentMark.cpp comparison

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 6862:8a5ea0a9ccc4

7127708: G1: change task num types from int to uint in concurrent mark Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich. Reviewed-by: johnc Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>

author	johnc
date	Sat, 06 Oct 2012 01:17:44 -0700
parents	988bf00cc564
children	4202510ee0fe

comparison

equal deleted inserted replaced

-:81e878c53615
+:8a5ea0a9ccc4
 _nextMarkBitMap(&_markBitMap2),
 _markStack(this),
 // _finger set in set_non_marking_state
-_max_task_num(MAX2((uint)ParallelGCThreads, 1U)),
+_max_worker_id(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)),
+_task_queues(new CMTaskQueueSet((int) _max_worker_id)),
-_terminator(ParallelTaskTerminator((int) _max_task_num, _task_queues)),
+_terminator(ParallelTaskTerminator((int) _max_worker_id, _task_queues)),
 _has_overflown(false),
 _concurrent(false),
 _has_aborted(false),
 _restart_for_overflow(false),
 SATBMarkQueueSet& satb_qs = JavaThread::satb_mark_queue_set();
 satb_qs.set_buffer_size(G1SATBBufferSize);
 _root_regions.init(_g1h, this);
-_tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_task_num, mtGC);
+_tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_worker_id, mtGC);
-_accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_task_num, mtGC);
+_accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_worker_id, mtGC);
-_count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap,  _max_task_num, mtGC);
+_count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap,  _max_worker_id, mtGC);
-_count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_task_num, mtGC);
+_count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_worker_id, mtGC);
 BitMap::idx_t card_bm_size = _card_bm.size();
 // so that the assertion in MarkingTaskQueue::task_queue doesn't fail
-_active_tasks = _max_task_num;
+_active_tasks = _max_worker_id;
-for (int i = 0; i < (int) _max_task_num; ++i) {
+for (uint i = 0; i < _max_worker_id; ++i) {
 CMTaskQueue* task_queue = new CMTaskQueue();
 task_queue->initialize();
 _task_queues->register_queue(i, task_queue);
 _count_card_bitmaps[i] = BitMap(card_bm_size, false);
 }
 // We do reset all of them, since different phases will use
 // different number of active threads. So, it's easiest to have all
 // of them ready.
-for (int i = 0; i < (int) _max_task_num; ++i) {
+for (uint i = 0; i < _max_worker_id; ++i) {
 _tasks[i]->reset(_nextMarkBitMap);
 }
 // 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(uint active_tasks, bool concurrent) {
-assert(active_tasks <= _max_task_num, "we should not have more");
+assert(active_tasks <= _max_worker_id, "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.
 _terminator   = ParallelTaskTerminator((int) active_tasks, _task_queues);
 _first_overflow_barrier_sync.set_n_workers((int) active_tasks);
 _second_overflow_barrier_sync.set_n_workers((int) active_tasks);
 _concurrent = concurrent;
 // We propagate this to all tasks, not just the active ones.
-for (int i = 0; i < (int) _max_task_num; ++i)
+for (uint i = 0; i < _max_worker_id; ++i)
 _tasks[i]->set_concurrent(concurrent);
 if (concurrent) {
 set_concurrent_marking_in_progress();
 } else {
 * could occur. This is actually safe, since the entering the sync
 * barrier is one of the last things do_marking_step() does, and it
 * doesn't manipulate any data structures afterwards.
 */
-void ConcurrentMark::enter_first_sync_barrier(int task_num) {
+void ConcurrentMark::enter_first_sync_barrier(uint worker_id) {
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%d] entering first barrier", task_num);
+gclog_or_tty->print_cr("[%u] entering first barrier", worker_id);
 }
 if (concurrent()) {
 ConcurrentGCThread::stsLeave();
 }
 }
 // at this point everyone should have synced up and not be doing any
 // more work
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%d] leaving first barrier", task_num);
+gclog_or_tty->print_cr("[%u] leaving first barrier", worker_id);
 }
-// let task 0 do this
+// let the task associated with with worker 0 do this
-if (task_num == 0) {
+if (worker_id == 0) {
 // task 0 is responsible for clearing the global data structures
 // We should be here because of an overflow. During STW we should
 // not clear the overflow flag since we rely on it being true when
 // we exit this method to abort the pause and restart concurent
 // marking.
 // after this, each task should reset its own data structures then
 // then go into the second barrier
 }
-void ConcurrentMark::enter_second_sync_barrier(int task_num) {
+void ConcurrentMark::enter_second_sync_barrier(uint worker_id) {
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%d] entering second barrier", task_num);
+gclog_or_tty->print_cr("[%u] entering second barrier", worker_id);
 }
 if (concurrent()) {
 ConcurrentGCThread::stsLeave();
 }
 ConcurrentGCThread::stsJoin();
 }
 // at this point everything should be re-initialised and ready to go
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%d] leaving second barrier", task_num);
+gclog_or_tty->print_cr("[%u] leaving second barrier", worker_id);
 }
 }
 #ifndef PRODUCT
 void ForceOverflowSettings::init() {
 template <class T> void do_oop_work(T* p) {
 if (!_cm->has_overflown()) {
 oop obj = oopDesc::load_decode_heap_oop(p);
 if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("\t[%d] we're looking at location "
+gclog_or_tty->print_cr("\t[%u] we're looking at location "
 "*"PTR_FORMAT" = "PTR_FORMAT,
-_task->task_id(), p, (void*) obj);
+_task->worker_id(), p, (void*) obj);
 }
 _task->deal_with_reference(obj);
 _ref_counter--;
 } while (_task->has_aborted() && !_cm->has_overflown());
 _ref_counter = _ref_counter_limit;
 }
 } else {
 if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("\t[%d] CM Overflow", _task->task_id());
+gclog_or_tty->print_cr("\t[%u] CM Overflow", _task->worker_id());
 }
 }
 }
 };
 _cm(cm), _task(task) { }
 void do_void() {
 do {
 if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("\t[%d] Drain: Calling do marking_step",
+gclog_or_tty->print_cr("\t[%u] Drain: Calling do marking_step",
-_task->task_id());
+_task->worker_id());
 }
 // We call CMTask::do_marking_step() to completely drain the local and
 // global marking stacks. The routine is called in a loop, which we'll
 // exit if there's nothing more to do (i.e. we'completely drained the
 g1_drain_mark_stack(this, &_markStack, &g1_keep_alive);
 // We use the work gang from the G1CollectedHeap and we utilize all
 // the worker threads.
 uint active_workers = g1h->workers() ? g1h->workers()->active_workers() : 1U;
-active_workers = MAX2(MIN2(active_workers, _max_task_num), 1U);
+active_workers = MAX2(MIN2(active_workers, _max_worker_id), 1U);
 G1CMRefProcTaskExecutor par_task_executor(g1h, this,
 g1h->workers(), active_workers);
 if (rp->processing_is_mt()) {
 clearRangePrevBitmap(mr);
 clearRangeNextBitmap(mr);
 }
 HeapRegion*
-ConcurrentMark::claim_region(int task_num) {
+ConcurrentMark::claim_region(uint worker_id) {
 // "checkpoint" the finger
 HeapWord* finger = _finger;
 // _heap_end will not change underneath our feet; it only changes at
 // yield points.
 HeapWord*   bottom        = curr_region->bottom();
 HeapWord*   end           = curr_region->end();
 HeapWord*   limit         = curr_region->next_top_at_mark_start();
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%d] curr_region = "PTR_FORMAT" "
+gclog_or_tty->print_cr("[%u] curr_region = "PTR_FORMAT" "
 "["PTR_FORMAT", "PTR_FORMAT"), "
 "limit = "PTR_FORMAT,
-task_num, curr_region, bottom, end, limit);
+worker_id, curr_region, bottom, end, limit);
 }
 // Is the gap between reading the finger and doing the CAS too long?
 HeapWord* res = (HeapWord*) Atomic::cmpxchg_ptr(end, &_finger, finger);
 if (res == finger) {
 // notice that _finger == end cannot be guaranteed here since,
 // someone else might have moved the finger even further
 assert(_finger >= end, "the finger should have moved forward");
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%d] we were successful with region = "
+gclog_or_tty->print_cr("[%u] we were successful with region = "
-PTR_FORMAT, task_num, curr_region);
+PTR_FORMAT, worker_id, curr_region);
 }
 if (limit > bottom) {
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%d] region "PTR_FORMAT" is not empty, "
+gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is not empty, "
-"returning it ", task_num, curr_region);
+"returning it ", worker_id, curr_region);
 }
 return curr_region;
 } else {
 assert(limit == bottom,
 "the region limit should be at bottom");
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%d] region "PTR_FORMAT" is empty, "
+gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is empty, "
-"returning NULL", task_num, curr_region);
+"returning NULL", worker_id, curr_region);
 }
 // we return NULL and the caller should try calling
 // claim_region() again.
 return NULL;
 }
 } else {
 assert(_finger > finger, "the finger should have moved forward");
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%d] somebody else moved the finger, "
+gclog_or_tty->print_cr("[%u] somebody else moved the finger, "
 "global finger = "PTR_FORMAT", "
 "our finger = "PTR_FORMAT,
-task_num, _finger, finger);
+worker_id, _finger, finger);
 }
 // read it again
 finger = _finger;
 }
 // Verify entries on the global mark stack
 cl.set_phase(VerifyNoCSetOopsStack);
 _markStack.oops_do(&cl);
 // Verify entries on the task queues
-for (int i = 0; i < (int) _max_task_num; i += 1) {
+for (uint i = 0; i < _max_worker_id; i += 1) {
 cl.set_phase(VerifyNoCSetOopsQueues, i);
 OopTaskQueue* queue = _task_queues->queue(i);
 queue->oops_do(&cl);
 }
 }
 err_msg("global finger: "PTR_FORMAT" region: "HR_FORMAT,
 global_finger, HR_FORMAT_PARAMS(global_hr)));
 }
 // Verify the task fingers
-assert(parallel_marking_threads() <= _max_task_num, "sanity");
+assert(parallel_marking_threads() <= _max_worker_id, "sanity");
 for (int i = 0; i < (int) parallel_marking_threads(); i += 1) {
 CMTask* task = _tasks[i];
 HeapWord* task_finger = task->finger();
 if (task_finger != NULL && task_finger < _heap_end) {
 // See above note on the global finger verification.
 } else {
 assert(has_overflown(), "pre-condition");
 }
 _finger = _heap_start;
-for (int i = 0; i < (int)_max_task_num; ++i) {
+for (uint i = 0; i < _max_worker_id; ++i) {
 OopTaskQueue* queue = _task_queues->queue(i);
 queue->set_empty();
 }
 }
 class AggregateCountDataHRClosure: public HeapRegionClosure {
 G1CollectedHeap* _g1h;
 ConcurrentMark* _cm;
 CardTableModRefBS* _ct_bs;
 BitMap* _cm_card_bm;
-size_t _max_task_num;
+uint _max_worker_id;
 public:
 AggregateCountDataHRClosure(G1CollectedHeap* g1h,
 BitMap* cm_card_bm,
-size_t max_task_num) :
+uint max_worker_id) :
 _g1h(g1h), _cm(g1h->concurrent_mark()),
 _ct_bs((CardTableModRefBS*) (g1h->barrier_set())),
-_cm_card_bm(cm_card_bm), _max_task_num(max_task_num) { }
+_cm_card_bm(cm_card_bm), _max_worker_id(max_worker_id) { }
 bool doHeapRegion(HeapRegion* hr) {
 if (hr->continuesHumongous()) {
 // We will ignore these here and process them when their
 // associated "starts humongous" region is processed.
 // Aggregate the "stripe" in the count data associated with hr.
 uint hrs_index = hr->hrs_index();
 size_t marked_bytes = 0;
-for (int i = 0; (size_t)i < _max_task_num; i += 1) {
+for (uint i = 0; i < _max_worker_id; i += 1) {
 size_t* marked_bytes_array = _cm->count_marked_bytes_array_for(i);
 BitMap* task_card_bm = _cm->count_card_bitmap_for(i);
 // Fetch the marked_bytes in this region for task i and
 // add it to the running total for this region.
 marked_bytes += marked_bytes_array[hrs_index];
-// Now union the bitmaps[0,max_task_num)[start_idx..limit_idx)
+// Now union the bitmaps[0,max_worker_id)[start_idx..limit_idx)
 // into the global card bitmap.
 BitMap::idx_t scan_idx = task_card_bm->get_next_one_offset(start_idx, limit_idx);
 while (scan_idx < limit_idx) {
 assert(task_card_bm->at(scan_idx) == true, "should be");
 class G1AggregateCountDataTask: public AbstractGangTask {
 protected:
 G1CollectedHeap* _g1h;
 ConcurrentMark* _cm;
 BitMap* _cm_card_bm;
-size_t _max_task_num;
+uint _max_worker_id;
 int _active_workers;
 public:
 G1AggregateCountDataTask(G1CollectedHeap* g1h,
 ConcurrentMark* cm,
 BitMap* cm_card_bm,
-size_t max_task_num,
+uint max_worker_id,
 int n_workers) :
 AbstractGangTask("Count Aggregation"),
 _g1h(g1h), _cm(cm), _cm_card_bm(cm_card_bm),
-_max_task_num(max_task_num),
+_max_worker_id(max_worker_id),
 _active_workers(n_workers) { }
 void work(uint worker_id) {
-AggregateCountDataHRClosure cl(_g1h, _cm_card_bm, _max_task_num);
+AggregateCountDataHRClosure cl(_g1h, _cm_card_bm, _max_worker_id);
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 _g1h->heap_region_par_iterate_chunked(&cl, worker_id,
 _active_workers,
 HeapRegion::AggregateCountClaimValue);
 int n_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
 _g1h->workers()->active_workers() :
 1);
 G1AggregateCountDataTask g1_par_agg_task(_g1h, this, &_card_bm,
-_max_task_num, n_workers);
+_max_worker_id, n_workers);
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 assert(_g1h->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
 "sanity check");
 _g1h->set_par_threads(n_workers);
 // Clear the global region bitmap - it will be filled as part
 // of the final counting task.
 _region_bm.clear();
 uint max_regions = _g1h->max_regions();
-assert(_max_task_num != 0, "unitialized");
+assert(_max_worker_id > 0, "uninitialized");
-for (int i = 0; (size_t) i < _max_task_num; i += 1) {
+for (uint i = 0; i < _max_worker_id; i += 1) {
 BitMap* task_card_bm = count_card_bitmap_for(i);
 size_t* marked_bytes_array = count_marked_bytes_array_for(i);
 assert(task_card_bm->size() == _card_bm.size(), "size mismatch");
 assert(marked_bytes_array != NULL, "uninitialized");
 _nextMarkBitMap->clearAll();
 // Clear the liveness counting data
 clear_all_count_data();
 // Empty mark stack
 clear_marking_state();
-for (int i = 0; i < (int)_max_task_num; ++i) {
+for (uint i = 0; i < _max_worker_id; ++i) {
 _tasks[i]->clear_region_fields();
 }
 _has_aborted = true;
 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
 #ifndef PRODUCT
 // for debugging purposes
 void ConcurrentMark::print_finger() {
 gclog_or_tty->print_cr("heap ["PTR_FORMAT", "PTR_FORMAT"), global finger = "PTR_FORMAT,
 _heap_start, _heap_end, _finger);
-for (int i = 0; i < (int) _max_task_num; ++i) {
+for (uint i = 0; i < _max_worker_id; ++i) {
-gclog_or_tty->print("   %d: "PTR_FORMAT, i, _tasks[i]->finger());
+gclog_or_tty->print("   %u: "PTR_FORMAT, i, _tasks[i]->finger());
 }
 gclog_or_tty->print_cr("");
 }
 #endif
 void CMTask::scan_object(oop obj) {
 assert(_nextMarkBitMap->isMarked((HeapWord*) obj), "invariant");
 if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("[%d] we're scanning object "PTR_FORMAT,
+gclog_or_tty->print_cr("[%u] we're scanning object "PTR_FORMAT,
-_task_id, (void*) obj);
+_worker_id, (void*) obj);
 }
 size_t obj_size = obj->size();
 _words_scanned += obj_size;
 "claim_region() should have filtered out continues humongous regions");
 assert(!hr->continuesHumongous(),
 "claim_region() should have filtered out continues humongous regions");
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] setting up for region "PTR_FORMAT,
+gclog_or_tty->print_cr("[%u] setting up for region "PTR_FORMAT,
-_task_id, hr);
+_worker_id, hr);
 }
 _curr_region  = hr;
 _finger       = hr->bottom();
 update_region_limit();
 HeapWord* bottom          = hr->bottom();
 HeapWord* limit           = hr->next_top_at_mark_start();
 if (limit == bottom) {
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] found an empty region "
+gclog_or_tty->print_cr("[%u] found an empty region "
 "["PTR_FORMAT", "PTR_FORMAT")",
-_task_id, bottom, limit);
+_worker_id, bottom, limit);
 }
 // The region was collected underneath our feet.
 // We set the finger to bottom to ensure that the bitmap
 // iteration that will follow this will not do anything.
 // (this is not a condition that holds when we set the region up,
 }
 void CMTask::giveup_current_region() {
 assert(_curr_region != NULL, "invariant");
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] giving up region "PTR_FORMAT,
+gclog_or_tty->print_cr("[%u] giving up region "PTR_FORMAT,
-_task_id, _curr_region);
+_worker_id, _curr_region);
 }
 clear_region_fields();
 }
 void CMTask::clear_region_fields() {
 void CMTask::reset(CMBitMap* nextMarkBitMap) {
 guarantee(nextMarkBitMap != NULL, "invariant");
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] resetting", _task_id);
+gclog_or_tty->print_cr("[%u] resetting", _worker_id);
 }
 _nextMarkBitMap                = nextMarkBitMap;
 clear_region_fields();
 double last_interval_ms = curr_time_ms - _interval_start_time_ms;
 _interval_start_time_ms = curr_time_ms;
 _all_clock_intervals_ms.add(last_interval_ms);
 if (_cm->verbose_medium()) {
-gclog_or_tty->print_cr("[%d] regular clock, interval = %1.2lfms, "
+gclog_or_tty->print_cr("[%u] regular clock, interval = %1.2lfms, "
 "scanned = %d%s, refs reached = %d%s",
-_task_id, last_interval_ms,
+_worker_id, last_interval_ms,
 _words_scanned,
 (_words_scanned >= _words_scanned_limit) ? " (*)" : "",
 _refs_reached,
 (_refs_reached >= _refs_reached_limit) ? " (*)" : "");
 }
 // (6) Finally, we check whether there are enough completed STAB
 // buffers available for processing. If there are, we abort.
 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
 if (!_draining_satb_buffers && satb_mq_set.process_completed_buffers()) {
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] aborting to deal with pending SATB buffers",
+gclog_or_tty->print_cr("[%u] aborting to deal with pending SATB buffers",
-_task_id);
+_worker_id);
 }
 // we do need to process SATB buffers, we'll abort and restart
 // the marking task to do so
 set_has_aborted();
 statsOnly( ++_aborted_satb );
 // operation which will increase the per byte scanned cost (i.e. move
 // entries to/from the global stack). It basically tries to decrease the
 // scanning limit so that the clock is called earlier.
 if (_cm->verbose_medium()) {
-gclog_or_tty->print_cr("[%d] decreasing limits", _task_id);
+gclog_or_tty->print_cr("[%u] decreasing limits", _worker_id);
 }
 _words_scanned_limit = _real_words_scanned_limit -
 3 * words_scanned_period / 4;
 _refs_reached_limit  = _real_refs_reached_limit -
 statsOnly( ++_global_transfers_to; _local_pops += n );
 if (!_cm->mark_stack_push(buffer, n)) {
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] aborting due to global stack overflow",
+gclog_or_tty->print_cr("[%u] aborting due to global stack overflow",
-_task_id);
+_worker_id);
 }
 set_has_aborted();
 } else {
 // the transfer was successful
 if (_cm->verbose_medium()) {
-gclog_or_tty->print_cr("[%d] pushed %d entries to the global stack",
+gclog_or_tty->print_cr("[%u] pushed %d entries to the global stack",
-_task_id, n);
+_worker_id, n);
 }
 statsOnly( int tmp_size = _cm->mark_stack_size();
 if (tmp_size > _global_max_size) {
 _global_max_size = tmp_size;
 }
 if (n > 0) {
 // yes, we did actually pop at least one entry
 statsOnly( ++_global_transfers_from; _global_pops += n );
 if (_cm->verbose_medium()) {
-gclog_or_tty->print_cr("[%d] popped %d entries from the global stack",
+gclog_or_tty->print_cr("[%u] popped %d entries from the global stack",
-_task_id, n);
+_worker_id, n);
 }
 for (int i = 0; i < n; ++i) {
 bool success = _task_queue->push(buffer[i]);
 // We only call this when the local queue is empty or under a
 // given target limit. So, we do not expect this push to fail.
 target_size = 0;
 }
 if (_task_queue->size() > target_size) {
 if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("[%d] draining local queue, target size = %d",
+gclog_or_tty->print_cr("[%u] draining local queue, target size = %d",
-_task_id, target_size);
+_worker_id, target_size);
 }
 oop obj;
 bool ret = _task_queue->pop_local(obj);
 while (ret) {
 statsOnly( ++_local_pops );
 if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("[%d] popped "PTR_FORMAT, _task_id,
+gclog_or_tty->print_cr("[%u] popped "PTR_FORMAT, _worker_id,
 (void*) obj);
 }
 assert(_g1h->is_in_g1_reserved((HeapWord*) obj), "invariant" );
 assert(!_g1h->is_on_master_free_list(
 ret = _task_queue->pop_local(obj);
 }
 }
 if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("[%d] drained local queue, size = %d",
+gclog_or_tty->print_cr("[%u] drained local queue, size = %d",
-_task_id, _task_queue->size());
+_worker_id, _task_queue->size());
 }
 }
 }
 void CMTask::drain_global_stack(bool partially) {
 target_size = 0;
 }
 if (_cm->mark_stack_size() > target_size) {
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] draining global_stack, target size %d",
+gclog_or_tty->print_cr("[%u] draining global_stack, target size %d",
-_task_id, target_size);
+_worker_id, target_size);
 }
 while (!has_aborted() && _cm->mark_stack_size() > target_size) {
 get_entries_from_global_stack();
 drain_local_queue(partially);
 }
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] drained global stack, size = %d",
+gclog_or_tty->print_cr("[%u] drained global stack, size = %d",
-_task_id, _cm->mark_stack_size());
+_worker_id, _cm->mark_stack_size());
 }
 }
 }
 // SATB Queue has several assumptions on whether to call the par or
 _draining_satb_buffers = true;
 CMObjectClosure oc(this);
 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-satb_mq_set.set_par_closure(_task_id, &oc);
+satb_mq_set.set_par_closure(_worker_id, &oc);
 } else {
 satb_mq_set.set_closure(&oc);
 }
 // This keeps claiming and applying the closure to completed buffers
 // until we run out of buffers or we need to abort.
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 while (!has_aborted() &&
-satb_mq_set.par_apply_closure_to_completed_buffer(_task_id)) {
+satb_mq_set.par_apply_closure_to_completed_buffer(_worker_id)) {
 if (_cm->verbose_medium()) {
-gclog_or_tty->print_cr("[%d] processed an SATB buffer", _task_id);
+gclog_or_tty->print_cr("[%u] processed an SATB buffer", _worker_id);
 }
 statsOnly( ++_satb_buffers_processed );
 regular_clock_call();
 }
 } else {
 while (!has_aborted() &&
 satb_mq_set.apply_closure_to_completed_buffer()) {
 if (_cm->verbose_medium()) {
-gclog_or_tty->print_cr("[%d] processed an SATB buffer", _task_id);
+gclog_or_tty->print_cr("[%u] processed an SATB buffer", _worker_id);
 }
 statsOnly( ++_satb_buffers_processed );
 regular_clock_call();
 }
 }
 if (!concurrent() && !has_aborted()) {
 // We should only do this during remark.
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-satb_mq_set.par_iterate_closure_all_threads(_task_id);
+satb_mq_set.par_iterate_closure_all_threads(_worker_id);
 } else {
 satb_mq_set.iterate_closure_all_threads();
 }
 }
 assert(has_aborted() ||
 concurrent() ||
 satb_mq_set.completed_buffers_num() == 0, "invariant");
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-satb_mq_set.set_par_closure(_task_id, NULL);
+satb_mq_set.set_par_closure(_worker_id, NULL);
 } else {
 satb_mq_set.set_closure(NULL);
 }
 // again, this was a potentially expensive operation, decrease the
 // limits to get the regular clock call early
 decrease_limits();
 }
 void CMTask::print_stats() {
-gclog_or_tty->print_cr("Marking Stats, task = %d, calls = %d",
+gclog_or_tty->print_cr("Marking Stats, task = %u, calls = %d",
-_task_id, _calls);
+_worker_id, _calls);
 gclog_or_tty->print_cr("  Elapsed time = %1.2lfms, Termination time = %1.2lfms",
 _elapsed_time_ms, _termination_time_ms);
 gclog_or_tty->print_cr("  Step Times (cum): num = %d, avg = %1.2lfms, sd = %1.2lfms",
 _step_times_ms.num(), _step_times_ms.avg(),
 _step_times_ms.sd());
 assert(concurrent() == _cm->concurrent(), "they should be the same");
 G1CollectorPolicy* g1_policy = _g1h->g1_policy();
 assert(_task_queues != NULL, "invariant");
 assert(_task_queue != NULL, "invariant");
-assert(_task_queues->queue(_task_id) == _task_queue, "invariant");
+assert(_task_queues->queue(_worker_id) == _task_queue, "invariant");
 assert(!_claimed,
 "only one thread should claim this task at any one time");
 // OK, this doesn't safeguard again all possible scenarios, as it is
 _draining_satb_buffers = false;
 ++_calls;
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] >>>>>>>>>> START, call = %d, "
+gclog_or_tty->print_cr("[%u] >>>>>>>>>> START, call = %d, "
 "target = %1.2lfms >>>>>>>>>>",
-_task_id, _calls, _time_target_ms);
+_worker_id, _calls, _time_target_ms);
 }
 // Set up the bitmap and oop closures. Anything that uses them is
 // eventually called from this method, so it is OK to allocate these
 // statically.
 // the address where we last found a marked object. If this is a
 // fresh region, _finger points to start().
 MemRegion mr = MemRegion(_finger, _region_limit);
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] we're scanning part "
+gclog_or_tty->print_cr("[%u] we're scanning part "
 "["PTR_FORMAT", "PTR_FORMAT") "
 "of region "PTR_FORMAT,
-_task_id, _finger, _region_limit, _curr_region);
+_worker_id, _finger, _region_limit, _curr_region);
 }
 // Let's iterate over the bitmap of the part of the
 // region that is left.
 if (mr.is_empty() || _nextMarkBitMap->iterate(&bitmap_closure, mr)) {
 // Separated the asserts so that we know which one fires.
 assert(_curr_region  == NULL, "invariant");
 assert(_finger       == NULL, "invariant");
 assert(_region_limit == NULL, "invariant");
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] trying to claim a new region", _task_id);
+gclog_or_tty->print_cr("[%u] trying to claim a new region", _worker_id);
 }
-HeapRegion* claimed_region = _cm->claim_region(_task_id);
+HeapRegion* claimed_region = _cm->claim_region(_worker_id);
 if (claimed_region != NULL) {
 // Yes, we managed to claim one
 statsOnly( ++_regions_claimed );
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] we successfully claimed "
+gclog_or_tty->print_cr("[%u] we successfully claimed "
 "region "PTR_FORMAT,
-_task_id, claimed_region);
+_worker_id, claimed_region);
 }
 setup_for_region(claimed_region);
 assert(_curr_region == claimed_region, "invariant");
 }
 // tasks might be pushing objects to it concurrently.
 assert(_cm->out_of_regions(),
 "at this point we should be out of regions");
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] all regions claimed", _task_id);
+gclog_or_tty->print_cr("[%u] all regions claimed", _worker_id);
 }
 // Try to reduce the number of available SATB buffers so that
 // remark has less work to do.
 drain_satb_buffers();
 // tasks might be pushing objects to it concurrently.
 assert(_cm->out_of_regions() && _task_queue->size() == 0,
 "only way to reach here");
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] starting to steal", _task_id);
+gclog_or_tty->print_cr("[%u] starting to steal", _worker_id);
 }
 while (!has_aborted()) {
 oop obj;
 statsOnly( ++_steal_attempts );
-if (_cm->try_stealing(_task_id, &_hash_seed, obj)) {
+if (_cm->try_stealing(_worker_id, &_hash_seed, obj)) {
 if (_cm->verbose_medium()) {
-gclog_or_tty->print_cr("[%d] stolen "PTR_FORMAT" successfully",
+gclog_or_tty->print_cr("[%u] stolen "PTR_FORMAT" successfully",
-_task_id, (void*) obj);
+_worker_id, (void*) obj);
 }
 statsOnly( ++_steals );
 assert(_nextMarkBitMap->isMarked((HeapWord*) obj),
 // Separated the asserts so that we know which one fires.
 assert(_cm->out_of_regions(), "only way to reach here");
 assert(_task_queue->size() == 0, "only way to reach here");
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] starting termination protocol", _task_id);
+gclog_or_tty->print_cr("[%u] starting termination protocol", _worker_id);
 }
 _termination_start_time_ms = os::elapsedVTime() * 1000.0;
 // The CMTask class also extends the TerminatorTerminator class,
 // hence its should_exit_termination() method will also decide
 termination_end_time_ms - _termination_start_time_ms;
 if (finished) {
 // We're all done.
-if (_task_id == 0) {
+if (_worker_id == 0) {
 // let's allow task 0 to do this
 if (concurrent()) {
 assert(_cm->concurrent_marking_in_progress(), "invariant");
 // we need to set this to false before the next
 // safepoint. This way we ensure that the marking phase
 guarantee(_task_queue->size() == 0, "only way to reach here");
 guarantee(!_cm->has_overflown(), "only way to reach here");
 guarantee(!_cm->mark_stack_overflow(), "only way to reach here");
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] all tasks terminated", _task_id);
+gclog_or_tty->print_cr("[%u] all tasks terminated", _worker_id);
 }
 } else {
 // Apparently there's more work to do. Let's abort this task. It
 // will restart it and we can hopefully find more things to do.
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] apparently there is more work to do",
+gclog_or_tty->print_cr("[%u] apparently there is more work to do",
-_task_id);
+_worker_id);
 }
 set_has_aborted();
 statsOnly( ++_aborted_termination );
 }
 // order to do this we have to make sure that all tasks stop
 // what they are doing and re-initialise in a safe manner. We
 // will achieve this with the use of two barrier sync points.
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] detected overflow", _task_id);
+gclog_or_tty->print_cr("[%u] detected overflow", _worker_id);
 }
-_cm->enter_first_sync_barrier(_task_id);
+_cm->enter_first_sync_barrier(_worker_id);
 // When we exit this sync barrier we know that all tasks have
 // stopped doing marking work. So, it's now safe to
 // re-initialise our data structures. At the end of this method,
 // task 0 will clear the global data structures.
 // We clear the local state of this task...
 clear_region_fields();
 // ...and enter the second barrier.
-_cm->enter_second_sync_barrier(_task_id);
+_cm->enter_second_sync_barrier(_worker_id);
 // At this point everything has bee re-initialised and we're
 // ready to restart.
 }
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] <<<<<<<<<< ABORTING, target = %1.2lfms, "
+gclog_or_tty->print_cr("[%u] <<<<<<<<<< ABORTING, target = %1.2lfms, "
 "elapsed = %1.2lfms <<<<<<<<<<",
-_task_id, _time_target_ms, elapsed_time_ms);
+_worker_id, _time_target_ms, elapsed_time_ms);
 if (_cm->has_aborted()) {
-gclog_or_tty->print_cr("[%d] ========== MARKING ABORTED ==========",
+gclog_or_tty->print_cr("[%u] ========== MARKING ABORTED ==========",
-_task_id);
+_worker_id);
 }
 }
 } else {
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] <<<<<<<<<< FINISHED, target = %1.2lfms, "
+gclog_or_tty->print_cr("[%u] <<<<<<<<<< FINISHED, target = %1.2lfms, "
 "elapsed = %1.2lfms <<<<<<<<<<",
-_task_id, _time_target_ms, elapsed_time_ms);
+_worker_id, _time_target_ms, elapsed_time_ms);
 }
 }
 _claimed = false;
 }
-CMTask::CMTask(int task_id,
+CMTask::CMTask(uint worker_id,
 ConcurrentMark* cm,
 size_t* marked_bytes,
 BitMap* card_bm,
 CMTaskQueue* task_queue,
 CMTaskQueueSet* task_queues)
 : _g1h(G1CollectedHeap::heap()),
-_task_id(task_id), _cm(cm),
+_worker_id(worker_id), _cm(cm),
 _claimed(false),
 _nextMarkBitMap(NULL), _hash_seed(17),
 _task_queue(task_queue),
 _task_queues(task_queues),
 _cm_oop_closure(NULL),

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 6862:8a5ea0a9ccc4