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

equal deleted inserted replaced

-:37f75ba502b1
+:289339903fcf
 _old_gc_alloc_region.set(retained_region);
 _hr_printer.reuse(retained_region);
 }
 }
-void G1CollectedHeap::release_gc_alloc_regions() {
+void G1CollectedHeap::release_gc_alloc_regions(uint no_of_gc_workers) {
 _survivor_gc_alloc_region.release();
 // If we have an old GC alloc region to release, we'll save it in
 // _retained_old_gc_alloc_region. If we don't
 // _retained_old_gc_alloc_region will become NULL. This is what we
 // want either way so no reason to check explicitly for either
 // condition.
 _retained_old_gc_alloc_region = _old_gc_alloc_region.release();
 if (ResizePLAB) {
-_survivor_plab_stats.adjust_desired_plab_sz();
+_survivor_plab_stats.adjust_desired_plab_sz(no_of_gc_workers);
-_old_plab_stats.adjust_desired_plab_sz();
+_old_plab_stats.adjust_desired_plab_sz(no_of_gc_workers);
 }
 }
 void G1CollectedHeap::abandon_gc_alloc_regions() {
 assert(_survivor_gc_alloc_region.get() == NULL, "pre-condition");
 assert(pss.refs()->is_empty(), "should be");
 }
 };
 // Weak Reference processing during an evacuation pause (part 1).
-void G1CollectedHeap::process_discovered_references() {
+void G1CollectedHeap::process_discovered_references(uint no_of_gc_workers) {
 double ref_proc_start = os::elapsedTime();
 ReferenceProcessor* rp = _ref_processor_stw;
 assert(rp->discovery_enabled(), "should have been enabled");
 // 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.
-uint active_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
-workers()->active_workers() : 1);
 assert(!G1CollectedHeap::use_parallel_gc_threads() ||
-active_workers == workers()->active_workers(),
+no_of_gc_workers == workers()->active_workers(),
-"Need to reset active_workers");
+"Need to reset active GC workers");
-set_par_threads(active_workers);
+set_par_threads(no_of_gc_workers);
-G1ParPreserveCMReferentsTask keep_cm_referents(this, active_workers, _task_queues);
+G1ParPreserveCMReferentsTask keep_cm_referents(this,
+no_of_gc_workers,
+_task_queues);
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 workers()->run_task(&keep_cm_referents);
 } else {
 keep_cm_referents.work(0);
 &keep_alive,
 &drain_queue,
 NULL);
 } else {
 // Parallel reference processing
-assert(rp->num_q() == active_workers, "sanity");
+assert(rp->num_q() == no_of_gc_workers, "sanity");
-assert(active_workers <= rp->max_num_q(), "sanity");
+assert(no_of_gc_workers <= rp->max_num_q(), "sanity");
-G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers);
+G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, no_of_gc_workers);
 rp->process_discovered_references(&is_alive, &keep_alive, &drain_queue, &par_task_executor);
 }
 // We have completed copying any necessary live referent objects
 // (that were not copied during the actual pause) so we can
 double ref_proc_time = os::elapsedTime() - ref_proc_start;
 g1_policy()->phase_times()->record_ref_proc_time(ref_proc_time * 1000.0);
 }
 // Weak Reference processing during an evacuation pause (part 2).
-void G1CollectedHeap::enqueue_discovered_references() {
+void G1CollectedHeap::enqueue_discovered_references(uint no_of_gc_workers) {
 double ref_enq_start = os::elapsedTime();
 ReferenceProcessor* rp = _ref_processor_stw;
 assert(!rp->discovery_enabled(), "should have been disabled as part of processing");
 // Serial reference processing...
 rp->enqueue_discovered_references();
 } else {
 // Parallel reference enqueuing
-uint active_workers = (ParallelGCThreads > 0 ? workers()->active_workers() : 1);
+assert(no_of_gc_workers == workers()->active_workers(),
-assert(active_workers == workers()->active_workers(),
+"Need to reset active workers");
-"Need to reset active_workers");
+assert(rp->num_q() == no_of_gc_workers, "sanity");
-assert(rp->num_q() == active_workers, "sanity");
+assert(no_of_gc_workers <= rp->max_num_q(), "sanity");
-assert(active_workers <= rp->max_num_q(), "sanity");
+G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, no_of_gc_workers);
-G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers);
 rp->enqueue_discovered_references(&par_task_executor);
 }
 rp->verify_no_references_recorded();
 assert(!rp->discovery_enabled(), "should have been disabled");
 // Process any discovered reference objects - we have
 // to do this _before_ we retire the GC alloc regions
 // as we may have to copy some 'reachable' referent
 // objects (and their reachable sub-graphs) that were
 // not copied during the pause.
-process_discovered_references();
+process_discovered_references(n_workers);
 // Weak root processing.
 // Note: when JSR 292 is enabled and code blobs can contain
 // non-perm oops then we will need to process the code blobs
 // here too.
 G1STWIsAliveClosure is_alive(this);
 G1KeepAliveClosure keep_alive(this);
 JNIHandles::weak_oops_do(&is_alive, &keep_alive);
 }
-release_gc_alloc_regions();
+release_gc_alloc_regions(n_workers);
 g1_rem_set()->cleanup_after_oops_into_collection_set_do();
 concurrent_g1_refine()->clear_hot_cache();
 concurrent_g1_refine()->set_use_cache(true);
 // this after the card table is cleaned (and verified) as
 // the act of enqueuing entries on to the pending list
 // will log these updates (and dirty their associated
 // cards). We need these updates logged to update any
 // RSets.
-enqueue_discovered_references();
+enqueue_discovered_references(n_workers);
 if (G1DeferredRSUpdate) {
 RedirtyLoggedCardTableEntryFastClosure redirty;
 dirty_card_queue_set().set_closure(&redirty);
 dirty_card_queue_set().apply_closure_to_all_completed_buffers();

changeset 13926	289339903fcf
parent 13876	8d0c8857ca32
child 14074	8cafb11da0cd