graal-compiler: src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 4728:441e946dc1af

7121618: Change type of number of GC workers to unsigned int. Summary: Change variables representing the number of GC workers to uint from int and size_t. Change the parameter in work(int i) to work(uint worker_id). Reviewed-by: brutisso, tonyp

author	jmasa
date	Wed, 14 Dec 2011 13:34:57 -0800
parents	adedfbbf0360
children	bacb651cf5bf

comparison

equal deleted inserted replaced

-:67fdcb391461
+:441e946dc1af
 ParRebuildRSTask(G1CollectedHeap* g1)
 : AbstractGangTask("ParRebuildRSTask"),
 _g1(g1)
 { }
-void work(int i) {
+void work(uint worker_id) {
-RebuildRSOutOfRegionClosure rebuild_rs(_g1, i);
+RebuildRSOutOfRegionClosure rebuild_rs(_g1, worker_id);
-_g1->heap_region_par_iterate_chunked(&rebuild_rs, i,
+_g1->heap_region_par_iterate_chunked(&rebuild_rs, worker_id,
 _g1->workers()->active_workers(),
 HeapRegion::RebuildRSClaimValue);
 }
 };
 _cg1r->clear_hot_cache();
 }
 // Rebuild remembered sets of all regions.
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-int n_workers =
+uint n_workers =
 AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(),
 workers()->active_workers(),
 Threads::number_of_non_daemon_threads());
 assert(UseDynamicNumberOfGCThreads ||
 n_workers == workers()->total_workers(),
 _hrs.iterate_from(r, cl);
 }
 void
 G1CollectedHeap::heap_region_par_iterate_chunked(HeapRegionClosure* cl,
-int worker,
+uint worker,
-int no_of_par_workers,
+uint no_of_par_workers,
 jint claim_value) {
 const size_t regions = n_regions();
-const size_t max_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
+const uint max_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
 no_of_par_workers :
 1);
 assert(UseDynamicNumberOfGCThreads ||
 no_of_par_workers == workers()->total_workers(),
 "Non dynamic should use fixed number of workers");
 // Then thread t will start at region floor ((t * n) / p)
 result = g1_policy()->collection_set();
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 size_t cs_size = g1_policy()->cset_region_length();
-int active_workers = workers()->active_workers();
+uint active_workers = workers()->active_workers();
 assert(UseDynamicNumberOfGCThreads ||
 active_workers == workers()->total_workers(),
 "Unless dynamic should use total workers");
 size_t end_ind   = (cs_size * worker_i) / active_workers;
 bool failures() {
 return _failures;
 }
-void work(int worker_i) {
+void work(uint worker_id) {
 HandleMark hm;
 VerifyRegionClosure blk(_allow_dirty, true, _vo);
-_g1h->heap_region_par_iterate_chunked(&blk, worker_i,
+_g1h->heap_region_par_iterate_chunked(&blk, worker_id,
 _g1h->workers()->active_workers(),
 HeapRegion::ParVerifyClaimValue);
 if (blk.failures()) {
 _failures = true;
 }
 class G1ParTask : public AbstractGangTask {
 protected:
 G1CollectedHeap*       _g1h;
 RefToScanQueueSet      *_queues;
 ParallelTaskTerminator _terminator;
-int _n_workers;
+uint _n_workers;
 Mutex _stats_lock;
 Mutex* stats_lock() { return &_stats_lock; }
 size_t getNCards() {
 _g1h->set_n_termination(active_workers);
 terminator()->reset_for_reuse(active_workers);
 _n_workers = active_workers;
 }
-void work(int i) {
+void work(uint worker_id) {
-if (i >= _n_workers) return;  // no work needed this round
+if (worker_id >= _n_workers) return;  // no work needed this round
 double start_time_ms = os::elapsedTime() * 1000.0;
-_g1h->g1_policy()->record_gc_worker_start_time(i, start_time_ms);
+_g1h->g1_policy()->record_gc_worker_start_time(worker_id, start_time_ms);
 ResourceMark rm;
 HandleMark   hm;
 ReferenceProcessor*             rp = _g1h->ref_processor_stw();
-G1ParScanThreadState            pss(_g1h, i);
+G1ParScanThreadState            pss(_g1h, worker_id);
 G1ParScanHeapEvacClosure        scan_evac_cl(_g1h, &pss, rp);
 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, rp);
 G1ParScanPartialArrayClosure    partial_scan_cl(_g1h, &pss, rp);
 pss.set_evac_closure(&scan_evac_cl);
 _g1h->g1_process_strong_roots(/* not collecting perm */ false,
 SharedHeap::SO_AllClasses,
 scan_root_cl,
 &push_heap_rs_cl,
 scan_perm_cl,
-i);
+worker_id);
 pss.end_strong_roots();
 {
 double start = os::elapsedTime();
 G1ParEvacuateFollowersClosure evac(_g1h, &pss, _queues, &_terminator);
 evac.do_void();
 double elapsed_ms = (os::elapsedTime()-start)*1000.0;
 double term_ms = pss.term_time()*1000.0;
-_g1h->g1_policy()->record_obj_copy_time(i, elapsed_ms-term_ms);
+_g1h->g1_policy()->record_obj_copy_time(worker_id, elapsed_ms-term_ms);
-_g1h->g1_policy()->record_termination(i, term_ms, pss.term_attempts());
+_g1h->g1_policy()->record_termination(worker_id, term_ms, pss.term_attempts());
 }
 _g1h->g1_policy()->record_thread_age_table(pss.age_table());
 _g1h->update_surviving_young_words(pss.surviving_young_words()+1);
 // Clean up any par-expanded rem sets.
 HeapRegionRemSet::par_cleanup();
 if (ParallelGCVerbose) {
 MutexLocker x(stats_lock());
-pss.print_termination_stats(i);
+pss.print_termination_stats(worker_id);
 }
 assert(pss.refs()->is_empty(), "should be empty");
 double end_time_ms = os::elapsedTime() * 1000.0;
-_g1h->g1_policy()->record_gc_worker_end_time(i, end_time_ms);
+_g1h->g1_policy()->record_gc_worker_end_time(worker_id, end_time_ms);
 }
 };
 // *** Common G1 Evacuation Stuff
 _g1h(g1h),
 _task_queues(task_queues),
 _terminator(terminator)
 {}
-virtual void work(int i) {
+virtual void work(uint worker_id) {
 // The reference processing task executed by a single worker.
 ResourceMark rm;
 HandleMark   hm;
 G1STWIsAliveClosure is_alive(_g1h);
-G1ParScanThreadState pss(_g1h, i);
+G1ParScanThreadState pss(_g1h, worker_id);
 G1ParScanHeapEvacClosure        scan_evac_cl(_g1h, &pss, NULL);
 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL);
 G1ParScanPartialArrayClosure    partial_scan_cl(_g1h, &pss, NULL);
 // Complete GC closure
 G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _task_queues, _terminator);
 // Call the reference processing task's work routine.
-_proc_task.work(i, is_alive, keep_alive, drain_queue);
+_proc_task.work(worker_id, is_alive, keep_alive, drain_queue);
 // Note we cannot assert that the refs array is empty here as not all
 // of the processing tasks (specifically phase2 - pp2_work) execute
 // the complete_gc closure (which ordinarily would drain the queue) so
 // the queue may not be empty.
 G1STWRefEnqueueTaskProxy(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);
 }
 };
 // Driver routine for parallel reference enqueing.
 // Creates an instance of the ref enqueueing gang
 class G1ParPreserveCMReferentsTask: public AbstractGangTask {
 protected:
 G1CollectedHeap* _g1h;
 RefToScanQueueSet      *_queues;
 ParallelTaskTerminator _terminator;
-int _n_workers;
+uint _n_workers;
 public:
 G1ParPreserveCMReferentsTask(G1CollectedHeap* g1h,int workers, RefToScanQueueSet *task_queues) :
 AbstractGangTask("ParPreserveCMReferents"),
 _g1h(g1h),
 _queues(task_queues),
 _terminator(workers, _queues),
 _n_workers(workers)
 { }
-void work(int i) {
+void work(uint worker_id) {
 ResourceMark rm;
 HandleMark   hm;
-G1ParScanThreadState            pss(_g1h, i);
+G1ParScanThreadState            pss(_g1h, worker_id);
 G1ParScanHeapEvacClosure        scan_evac_cl(_g1h, &pss, NULL);
 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL);
 G1ParScanPartialArrayClosure    partial_scan_cl(_g1h, &pss, NULL);
 pss.set_evac_closure(&scan_evac_cl);
 // to be copied.
 G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, copy_perm_cl, &pss);
 ReferenceProcessor* rp = _g1h->ref_processor_cm();
-int limit = ReferenceProcessor::number_of_subclasses_of_ref() * rp->max_num_q();
+uint limit = ReferenceProcessor::number_of_subclasses_of_ref() * rp->max_num_q();
-int stride = MIN2(MAX2(_n_workers, 1), limit);
+uint stride = MIN2(MAX2(_n_workers, 1U), limit);
 // limit is set using max_num_q() - which was set using ParallelGCThreads.
 // So this must be true - but assert just in case someone decides to
 // change the worker ids.
-assert(0 <= i && i < limit, "sanity");
+assert(0 <= worker_id && worker_id < limit, "sanity");
 assert(!rp->discovery_is_atomic(), "check this code");
 // Select discovered lists [i, i+stride, i+2*stride,...,limit)
-for (int idx = i; idx < limit; idx += stride) {
+for (uint idx = worker_id; idx < limit; idx += stride) {
 DiscoveredList& ref_list = rp->discovered_refs()[idx];
 DiscoveredListIterator iter(ref_list, &keep_alive, &always_alive);
 while (iter.has_next()) {
 // Since discovery is not atomic for the CM ref processor, we
 // We also need to do this copying before we process the reference
 // objects discovered by the STW ref processor in case one of these
 // referents points to another object which is also referenced by an
 // object discovered by the STW ref processor.
-int active_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
+uint active_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
 workers()->active_workers() : 1);
 assert(!G1CollectedHeap::use_parallel_gc_threads() ||
 active_workers == workers()->active_workers(),
 "Need to reset active_workers");
 // Serial reference processing...
 rp->enqueue_discovered_references();
 } else {
 // Parallel reference enqueuing
-int active_workers = (ParallelGCThreads > 0 ? workers()->active_workers() : 1);
+uint active_workers = (ParallelGCThreads > 0 ? workers()->active_workers() : 1);
 assert(active_workers == workers()->active_workers(),
 "Need to reset active_workers");
 assert(rp->num_q() == active_workers, "sanity");
 assert(active_workers <= rp->max_num_q(), "sanity");
 g1_rem_set()->prepare_for_oops_into_collection_set_do();
 concurrent_g1_refine()->set_use_cache(false);
 concurrent_g1_refine()->clear_hot_cache_claimed_index();
-int n_workers;
+uint n_workers;
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 n_workers =
 AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(),
 workers()->active_workers(),
 Threads::number_of_non_daemon_threads());
 G1ParCleanupCTTask(CardTableModRefBS* ct_bs,
 G1CollectedHeap* g1h) :
 AbstractGangTask("G1 Par Cleanup CT Task"),
 _ct_bs(ct_bs), _g1h(g1h) { }
-void work(int i) {
+void work(uint worker_id) {
 HeapRegion* r;
 while (r = _g1h->pop_dirty_cards_region()) {
 clear_cards(r);
 }
 }
 void G1CollectedHeap::set_par_threads() {
 // Don't change the number of workers.  Use the value previously set
 // in the workgroup.
 assert(G1CollectedHeap::use_parallel_gc_threads(), "shouldn't be here otherwise");
-int n_workers = workers()->active_workers();
+uint n_workers = workers()->active_workers();
 assert(UseDynamicNumberOfGCThreads ||
 n_workers == workers()->total_workers(),
 "Otherwise should be using the total number of workers");
 if (n_workers == 0) {
 assert(false, "Should have been set in prior evacuation pause.");

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 4728:441e946dc1af