Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 6819:2e6857353b2c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8000311: G1: ParallelGCThreads==0 broken Summary: Divide by zero error, if ParallelGCThreads is 0, when adjusting the PLAB size. Reviewed-by: jmasa, jcoomes
author johnc
date Thu, 04 Oct 2012 10:04:13 -0700
parents b86575d092a2
children 04155d9c8c76
comparison
equal deleted inserted replaced
6818:22b8d3d181d9 6819:2e6857353b2c
4149 _old_gc_alloc_region.set(retained_region); 4149 _old_gc_alloc_region.set(retained_region);
4150 _hr_printer.reuse(retained_region); 4150 _hr_printer.reuse(retained_region);
4151 } 4151 }
4152 } 4152 }
4153 4153
4154 void G1CollectedHeap::release_gc_alloc_regions() { 4154 void G1CollectedHeap::release_gc_alloc_regions(uint no_of_gc_workers) {
4155 _survivor_gc_alloc_region.release(); 4155 _survivor_gc_alloc_region.release();
4156 // If we have an old GC alloc region to release, we'll save it in 4156 // If we have an old GC alloc region to release, we'll save it in
4157 // _retained_old_gc_alloc_region. If we don't 4157 // _retained_old_gc_alloc_region. If we don't
4158 // _retained_old_gc_alloc_region will become NULL. This is what we 4158 // _retained_old_gc_alloc_region will become NULL. This is what we
4159 // want either way so no reason to check explicitly for either 4159 // want either way so no reason to check explicitly for either
4160 // condition. 4160 // condition.
4161 _retained_old_gc_alloc_region = _old_gc_alloc_region.release(); 4161 _retained_old_gc_alloc_region = _old_gc_alloc_region.release();
4162 4162
4163 if (ResizePLAB) { 4163 if (ResizePLAB) {
4164 _survivor_plab_stats.adjust_desired_plab_sz(); 4164 _survivor_plab_stats.adjust_desired_plab_sz(no_of_gc_workers);
4165 _old_plab_stats.adjust_desired_plab_sz(); 4165 _old_plab_stats.adjust_desired_plab_sz(no_of_gc_workers);
4166 } 4166 }
4167 } 4167 }
4168 4168
4169 void G1CollectedHeap::abandon_gc_alloc_regions() { 4169 void G1CollectedHeap::abandon_gc_alloc_regions() {
4170 assert(_survivor_gc_alloc_region.get() == NULL, "pre-condition"); 4170 assert(_survivor_gc_alloc_region.get() == NULL, "pre-condition");
5425 assert(pss.refs()->is_empty(), "should be"); 5425 assert(pss.refs()->is_empty(), "should be");
5426 } 5426 }
5427 }; 5427 };
5428 5428
5429 // Weak Reference processing during an evacuation pause (part 1). 5429 // Weak Reference processing during an evacuation pause (part 1).
5430 void G1CollectedHeap::process_discovered_references() { 5430 void G1CollectedHeap::process_discovered_references(uint no_of_gc_workers) {
5431 double ref_proc_start = os::elapsedTime(); 5431 double ref_proc_start = os::elapsedTime();
5432 5432
5433 ReferenceProcessor* rp = _ref_processor_stw; 5433 ReferenceProcessor* rp = _ref_processor_stw;
5434 assert(rp->discovery_enabled(), "should have been enabled"); 5434 assert(rp->discovery_enabled(), "should have been enabled");
5435 5435
5452 // We also need to do this copying before we process the reference 5452 // We also need to do this copying before we process the reference
5453 // objects discovered by the STW ref processor in case one of these 5453 // objects discovered by the STW ref processor in case one of these
5454 // referents points to another object which is also referenced by an 5454 // referents points to another object which is also referenced by an
5455 // object discovered by the STW ref processor. 5455 // object discovered by the STW ref processor.
5456 5456
5457 uint active_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
5458 workers()->active_workers() : 1);
5459
5460 assert(!G1CollectedHeap::use_parallel_gc_threads() || 5457 assert(!G1CollectedHeap::use_parallel_gc_threads() ||
5461 active_workers == workers()->active_workers(), 5458 no_of_gc_workers == workers()->active_workers(),
5462 "Need to reset active_workers"); 5459 "Need to reset active GC workers");
5463 5460
5464 set_par_threads(active_workers); 5461 set_par_threads(no_of_gc_workers);
5465 G1ParPreserveCMReferentsTask keep_cm_referents(this, active_workers, _task_queues); 5462 G1ParPreserveCMReferentsTask keep_cm_referents(this,
5463 no_of_gc_workers,
5464 _task_queues);
5466 5465
5467 if (G1CollectedHeap::use_parallel_gc_threads()) { 5466 if (G1CollectedHeap::use_parallel_gc_threads()) {
5468 workers()->run_task(&keep_cm_referents); 5467 workers()->run_task(&keep_cm_referents);
5469 } else { 5468 } else {
5470 keep_cm_referents.work(0); 5469 keep_cm_referents.work(0);
5526 &keep_alive, 5525 &keep_alive,
5527 &drain_queue, 5526 &drain_queue,
5528 NULL); 5527 NULL);
5529 } else { 5528 } else {
5530 // Parallel reference processing 5529 // Parallel reference processing
5531 assert(rp->num_q() == active_workers, "sanity"); 5530 assert(rp->num_q() == no_of_gc_workers, "sanity");
5532 assert(active_workers <= rp->max_num_q(), "sanity"); 5531 assert(no_of_gc_workers <= rp->max_num_q(), "sanity");
5533 5532
5534 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers); 5533 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, no_of_gc_workers);
5535 rp->process_discovered_references(&is_alive, &keep_alive, &drain_queue, &par_task_executor); 5534 rp->process_discovered_references(&is_alive, &keep_alive, &drain_queue, &par_task_executor);
5536 } 5535 }
5537 5536
5538 // We have completed copying any necessary live referent objects 5537 // We have completed copying any necessary live referent objects
5539 // (that were not copied during the actual pause) so we can 5538 // (that were not copied during the actual pause) so we can
5544 double ref_proc_time = os::elapsedTime() - ref_proc_start; 5543 double ref_proc_time = os::elapsedTime() - ref_proc_start;
5545 g1_policy()->phase_times()->record_ref_proc_time(ref_proc_time * 1000.0); 5544 g1_policy()->phase_times()->record_ref_proc_time(ref_proc_time * 1000.0);
5546 } 5545 }
5547 5546
5548 // Weak Reference processing during an evacuation pause (part 2). 5547 // Weak Reference processing during an evacuation pause (part 2).
5549 void G1CollectedHeap::enqueue_discovered_references() { 5548 void G1CollectedHeap::enqueue_discovered_references(uint no_of_gc_workers) {
5550 double ref_enq_start = os::elapsedTime(); 5549 double ref_enq_start = os::elapsedTime();
5551 5550
5552 ReferenceProcessor* rp = _ref_processor_stw; 5551 ReferenceProcessor* rp = _ref_processor_stw;
5553 assert(!rp->discovery_enabled(), "should have been disabled as part of processing"); 5552 assert(!rp->discovery_enabled(), "should have been disabled as part of processing");
5554 5553
5558 // Serial reference processing... 5557 // Serial reference processing...
5559 rp->enqueue_discovered_references(); 5558 rp->enqueue_discovered_references();
5560 } else { 5559 } else {
5561 // Parallel reference enqueuing 5560 // Parallel reference enqueuing
5562 5561
5563 uint active_workers = (ParallelGCThreads > 0 ? workers()->active_workers() : 1); 5562 assert(no_of_gc_workers == workers()->active_workers(),
5564 assert(active_workers == workers()->active_workers(), 5563 "Need to reset active workers");
5565 "Need to reset active_workers"); 5564 assert(rp->num_q() == no_of_gc_workers, "sanity");
5566 assert(rp->num_q() == active_workers, "sanity"); 5565 assert(no_of_gc_workers <= rp->max_num_q(), "sanity");
5567 assert(active_workers <= rp->max_num_q(), "sanity"); 5566
5568 5567 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, no_of_gc_workers);
5569 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, active_workers);
5570 rp->enqueue_discovered_references(&par_task_executor); 5568 rp->enqueue_discovered_references(&par_task_executor);
5571 } 5569 }
5572 5570
5573 rp->verify_no_references_recorded(); 5571 rp->verify_no_references_recorded();
5574 assert(!rp->discovery_enabled(), "should have been disabled"); 5572 assert(!rp->discovery_enabled(), "should have been disabled");
5656 // Process any discovered reference objects - we have 5654 // Process any discovered reference objects - we have
5657 // to do this _before_ we retire the GC alloc regions 5655 // to do this _before_ we retire the GC alloc regions
5658 // as we may have to copy some 'reachable' referent 5656 // as we may have to copy some 'reachable' referent
5659 // objects (and their reachable sub-graphs) that were 5657 // objects (and their reachable sub-graphs) that were
5660 // not copied during the pause. 5658 // not copied during the pause.
5661 process_discovered_references(); 5659 process_discovered_references(n_workers);
5662 5660
5663 // Weak root processing. 5661 // Weak root processing.
5664 // Note: when JSR 292 is enabled and code blobs can contain 5662 // Note: when JSR 292 is enabled and code blobs can contain
5665 // non-perm oops then we will need to process the code blobs 5663 // non-perm oops then we will need to process the code blobs
5666 // here too. 5664 // here too.
5668 G1STWIsAliveClosure is_alive(this); 5666 G1STWIsAliveClosure is_alive(this);
5669 G1KeepAliveClosure keep_alive(this); 5667 G1KeepAliveClosure keep_alive(this);
5670 JNIHandles::weak_oops_do(&is_alive, &keep_alive); 5668 JNIHandles::weak_oops_do(&is_alive, &keep_alive);
5671 } 5669 }
5672 5670
5673 release_gc_alloc_regions(); 5671 release_gc_alloc_regions(n_workers);
5674 g1_rem_set()->cleanup_after_oops_into_collection_set_do(); 5672 g1_rem_set()->cleanup_after_oops_into_collection_set_do();
5675 5673
5676 concurrent_g1_refine()->clear_hot_cache(); 5674 concurrent_g1_refine()->clear_hot_cache();
5677 concurrent_g1_refine()->set_use_cache(true); 5675 concurrent_g1_refine()->set_use_cache(true);
5678 5676
5692 // this after the card table is cleaned (and verified) as 5690 // this after the card table is cleaned (and verified) as
5693 // the act of enqueuing entries on to the pending list 5691 // the act of enqueuing entries on to the pending list
5694 // will log these updates (and dirty their associated 5692 // will log these updates (and dirty their associated
5695 // cards). We need these updates logged to update any 5693 // cards). We need these updates logged to update any
5696 // RSets. 5694 // RSets.
5697 enqueue_discovered_references(); 5695 enqueue_discovered_references(n_workers);
5698 5696
5699 if (G1DeferredRSUpdate) { 5697 if (G1DeferredRSUpdate) {
5700 RedirtyLoggedCardTableEntryFastClosure redirty; 5698 RedirtyLoggedCardTableEntryFastClosure redirty;
5701 dirty_card_queue_set().set_closure(&redirty); 5699 dirty_card_queue_set().set_closure(&redirty);
5702 dirty_card_queue_set().apply_closure_to_all_completed_buffers(); 5700 dirty_card_queue_set().apply_closure_to_all_completed_buffers();