Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp @ 10185:d50cc62e94ff
8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t
Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime.
Reviewed-by: twisti, johnc
Contributed-by: Martin Doerr <martin.doerr@sap.com>
| author | johnc |
|---|---|
| date | Wed, 24 Apr 2013 14:48:43 -0700 |
| parents | 203f64878aab |
| children | b06ac540229e |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6865
diff
changeset
|
2 * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
|
2379
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
26 #include "classfile/symbolTable.hpp" |
| 4909 | 27 #include "code/codeCache.hpp" |
| 1972 | 28 #include "gc_implementation/parallelScavenge/cardTableExtension.hpp" |
| 29 #include "gc_implementation/parallelScavenge/gcTaskManager.hpp" | |
| 30 #include "gc_implementation/parallelScavenge/generationSizer.hpp" | |
| 31 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" | |
| 32 #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp" | |
| 33 #include "gc_implementation/parallelScavenge/psMarkSweep.hpp" | |
| 34 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp" | |
| 35 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp" | |
| 36 #include "gc_implementation/parallelScavenge/psTasks.hpp" | |
| 37 #include "gc_implementation/shared/isGCActiveMark.hpp" | |
| 38 #include "gc_implementation/shared/spaceDecorator.hpp" | |
| 39 #include "gc_interface/gcCause.hpp" | |
| 40 #include "memory/collectorPolicy.hpp" | |
| 41 #include "memory/gcLocker.inline.hpp" | |
| 42 #include "memory/referencePolicy.hpp" | |
| 43 #include "memory/referenceProcessor.hpp" | |
| 44 #include "memory/resourceArea.hpp" | |
| 45 #include "oops/oop.inline.hpp" | |
| 46 #include "oops/oop.psgc.inline.hpp" | |
| 47 #include "runtime/biasedLocking.hpp" | |
| 48 #include "runtime/fprofiler.hpp" | |
| 49 #include "runtime/handles.inline.hpp" | |
| 50 #include "runtime/threadCritical.hpp" | |
| 51 #include "runtime/vmThread.hpp" | |
| 52 #include "runtime/vm_operations.hpp" | |
| 53 #include "services/memoryService.hpp" | |
| 54 #include "utilities/stack.inline.hpp" | |
| 0 | 55 |
| 56 | |
| 57 HeapWord* PSScavenge::_to_space_top_before_gc = NULL; | |
| 58 int PSScavenge::_consecutive_skipped_scavenges = 0; | |
| 59 ReferenceProcessor* PSScavenge::_ref_processor = NULL; | |
| 60 CardTableExtension* PSScavenge::_card_table = NULL; | |
| 61 bool PSScavenge::_survivor_overflow = false; | |
| 6818 | 62 uint PSScavenge::_tenuring_threshold = 0; |
| 0 | 63 HeapWord* PSScavenge::_young_generation_boundary = NULL; |
| 64 elapsedTimer PSScavenge::_accumulated_time; | |
| 6197 | 65 Stack<markOop, mtGC> PSScavenge::_preserved_mark_stack; |
| 66 Stack<oop, mtGC> PSScavenge::_preserved_oop_stack; | |
| 0 | 67 CollectorCounters* PSScavenge::_counters = NULL; |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
68 bool PSScavenge::_promotion_failed = false; |
| 0 | 69 |
| 70 // Define before use | |
| 71 class PSIsAliveClosure: public BoolObjectClosure { | |
| 72 public: | |
| 73 void do_object(oop p) { | |
| 74 assert(false, "Do not call."); | |
| 75 } | |
| 76 bool do_object_b(oop p) { | |
| 77 return (!PSScavenge::is_obj_in_young((HeapWord*) p)) || p->is_forwarded(); | |
| 78 } | |
| 79 }; | |
| 80 | |
| 81 PSIsAliveClosure PSScavenge::_is_alive_closure; | |
| 82 | |
| 83 class PSKeepAliveClosure: public OopClosure { | |
| 84 protected: | |
| 85 MutableSpace* _to_space; | |
| 86 PSPromotionManager* _promotion_manager; | |
| 87 | |
| 88 public: | |
| 89 PSKeepAliveClosure(PSPromotionManager* pm) : _promotion_manager(pm) { | |
| 90 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 91 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 92 _to_space = heap->young_gen()->to_space(); | |
| 93 | |
| 94 assert(_promotion_manager != NULL, "Sanity"); | |
| 95 } | |
| 96 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
97 template <class T> void do_oop_work(T* p) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
98 assert (!oopDesc::is_null(*p), "expected non-null ref"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
99 assert ((oopDesc::load_decode_heap_oop_not_null(p))->is_oop(), |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
100 "expected an oop while scanning weak refs"); |
| 0 | 101 |
| 102 // Weak refs may be visited more than once. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
103 if (PSScavenge::should_scavenge(p, _to_space)) { |
| 4909 | 104 PSScavenge::copy_and_push_safe_barrier<T, /*promote_immediately=*/false>(_promotion_manager, p); |
| 0 | 105 } |
| 106 } | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
107 virtual void do_oop(oop* p) { PSKeepAliveClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
108 virtual void do_oop(narrowOop* p) { PSKeepAliveClosure::do_oop_work(p); } |
| 0 | 109 }; |
| 110 | |
| 111 class PSEvacuateFollowersClosure: public VoidClosure { | |
| 112 private: | |
| 113 PSPromotionManager* _promotion_manager; | |
| 114 public: | |
| 115 PSEvacuateFollowersClosure(PSPromotionManager* pm) : _promotion_manager(pm) {} | |
| 116 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
117 virtual void do_void() { |
| 0 | 118 assert(_promotion_manager != NULL, "Sanity"); |
| 119 _promotion_manager->drain_stacks(true); | |
| 120 guarantee(_promotion_manager->stacks_empty(), | |
| 121 "stacks should be empty at this point"); | |
| 122 } | |
| 123 }; | |
| 124 | |
| 125 class PSPromotionFailedClosure : public ObjectClosure { | |
| 126 virtual void do_object(oop obj) { | |
| 127 if (obj->is_forwarded()) { | |
| 128 obj->init_mark(); | |
| 129 } | |
| 130 } | |
| 131 }; | |
| 132 | |
| 133 class PSRefProcTaskProxy: public GCTask { | |
| 134 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; | |
| 135 ProcessTask & _rp_task; | |
| 136 uint _work_id; | |
| 137 public: | |
| 138 PSRefProcTaskProxy(ProcessTask & rp_task, uint work_id) | |
| 139 : _rp_task(rp_task), | |
| 140 _work_id(work_id) | |
| 141 { } | |
| 142 | |
| 143 private: | |
| 144 virtual char* name() { return (char *)"Process referents by policy in parallel"; } | |
| 145 virtual void do_it(GCTaskManager* manager, uint which); | |
| 146 }; | |
| 147 | |
| 148 void PSRefProcTaskProxy::do_it(GCTaskManager* manager, uint which) | |
| 149 { | |
| 150 PSPromotionManager* promotion_manager = | |
| 151 PSPromotionManager::gc_thread_promotion_manager(which); | |
| 152 assert(promotion_manager != NULL, "sanity check"); | |
| 153 PSKeepAliveClosure keep_alive(promotion_manager); | |
| 154 PSEvacuateFollowersClosure evac_followers(promotion_manager); | |
| 155 PSIsAliveClosure is_alive; | |
| 156 _rp_task.work(_work_id, is_alive, keep_alive, evac_followers); | |
| 157 } | |
| 158 | |
| 159 class PSRefEnqueueTaskProxy: public GCTask { | |
| 160 typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask; | |
| 161 EnqueueTask& _enq_task; | |
| 162 uint _work_id; | |
| 163 | |
| 164 public: | |
| 165 PSRefEnqueueTaskProxy(EnqueueTask& enq_task, uint work_id) | |
| 166 : _enq_task(enq_task), | |
| 167 _work_id(work_id) | |
| 168 { } | |
| 169 | |
| 170 virtual char* name() { return (char *)"Enqueue reference objects in parallel"; } | |
| 171 virtual void do_it(GCTaskManager* manager, uint which) | |
| 172 { | |
| 173 _enq_task.work(_work_id); | |
| 174 } | |
| 175 }; | |
| 176 | |
| 177 class PSRefProcTaskExecutor: public AbstractRefProcTaskExecutor { | |
| 178 virtual void execute(ProcessTask& task); | |
| 179 virtual void execute(EnqueueTask& task); | |
| 180 }; | |
| 181 | |
| 182 void PSRefProcTaskExecutor::execute(ProcessTask& task) | |
| 183 { | |
| 184 GCTaskQueue* q = GCTaskQueue::create(); | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
185 GCTaskManager* manager = ParallelScavengeHeap::gc_task_manager(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
186 for(uint i=0; i < manager->active_workers(); i++) { |
| 0 | 187 q->enqueue(new PSRefProcTaskProxy(task, i)); |
| 188 } | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
189 ParallelTaskTerminator terminator(manager->active_workers(), |
|
1706
9d7a8ab3736b
6962589: remove breadth first scanning code from parallel gc
tonyp
parents:
1638
diff
changeset
|
190 (TaskQueueSetSuper*) PSPromotionManager::stack_array_depth()); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
191 if (task.marks_oops_alive() && manager->active_workers() > 1) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
192 for (uint j = 0; j < manager->active_workers(); j++) { |
| 0 | 193 q->enqueue(new StealTask(&terminator)); |
| 194 } | |
| 195 } | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
196 manager->execute_and_wait(q); |
| 0 | 197 } |
| 198 | |
| 199 | |
| 200 void PSRefProcTaskExecutor::execute(EnqueueTask& task) | |
| 201 { | |
| 202 GCTaskQueue* q = GCTaskQueue::create(); | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
203 GCTaskManager* manager = ParallelScavengeHeap::gc_task_manager(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
204 for(uint i=0; i < manager->active_workers(); i++) { |
| 0 | 205 q->enqueue(new PSRefEnqueueTaskProxy(task, i)); |
| 206 } | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
207 manager->execute_and_wait(q); |
| 0 | 208 } |
| 209 | |
| 210 // This method contains all heap specific policy for invoking scavenge. | |
| 211 // PSScavenge::invoke_no_policy() will do nothing but attempt to | |
| 212 // scavenge. It will not clean up after failed promotions, bail out if | |
| 213 // we've exceeded policy time limits, or any other special behavior. | |
| 214 // All such policy should be placed here. | |
| 215 // | |
| 216 // Note that this method should only be called from the vm_thread while | |
| 217 // at a safepoint! | |
|
4913
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
218 bool PSScavenge::invoke() { |
| 0 | 219 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); |
| 220 assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread"); | |
| 221 assert(!Universe::heap()->is_gc_active(), "not reentrant"); | |
| 222 | |
|
4913
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
223 ParallelScavengeHeap* const heap = (ParallelScavengeHeap*)Universe::heap(); |
| 0 | 224 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); |
| 225 | |
| 226 PSAdaptiveSizePolicy* policy = heap->size_policy(); | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
227 IsGCActiveMark mark; |
| 0 | 228 |
|
4913
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
229 const bool scavenge_done = PSScavenge::invoke_no_policy(); |
|
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
230 const bool need_full_gc = !scavenge_done || |
|
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
231 policy->should_full_GC(heap->old_gen()->free_in_bytes()); |
|
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
232 bool full_gc_done = false; |
| 0 | 233 |
|
4913
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
234 if (UsePerfData) { |
|
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
235 PSGCAdaptivePolicyCounters* const counters = heap->gc_policy_counters(); |
|
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
236 const int ffs_val = need_full_gc ? full_follows_scavenge : not_skipped; |
|
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
237 counters->update_full_follows_scavenge(ffs_val); |
|
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
238 } |
|
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
239 |
|
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
240 if (need_full_gc) { |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
241 GCCauseSetter gccs(heap, GCCause::_adaptive_size_policy); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
242 CollectorPolicy* cp = heap->collector_policy(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
243 const bool clear_all_softrefs = cp->should_clear_all_soft_refs(); |
| 0 | 244 |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
245 if (UseParallelOldGC) { |
|
4913
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
246 full_gc_done = PSParallelCompact::invoke_no_policy(clear_all_softrefs); |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
247 } else { |
|
4913
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
248 full_gc_done = PSMarkSweep::invoke_no_policy(clear_all_softrefs); |
| 0 | 249 } |
| 250 } | |
|
4913
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
251 |
|
ab4422d0ed59
7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents:
4909
diff
changeset
|
252 return full_gc_done; |
| 0 | 253 } |
| 254 | |
| 255 // This method contains no policy. You should probably | |
| 256 // be calling invoke() instead. | |
| 257 bool PSScavenge::invoke_no_policy() { | |
| 258 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); | |
| 259 assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread"); | |
| 260 | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
261 assert(_preserved_mark_stack.is_empty(), "should be empty"); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
262 assert(_preserved_oop_stack.is_empty(), "should be empty"); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
263 |
| 0 | 264 TimeStamp scavenge_entry; |
| 265 TimeStamp scavenge_midpoint; | |
| 266 TimeStamp scavenge_exit; | |
| 267 | |
| 268 scavenge_entry.update(); | |
| 269 | |
| 270 if (GC_locker::check_active_before_gc()) { | |
| 271 return false; | |
| 272 } | |
| 273 | |
| 274 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 275 GCCause::Cause gc_cause = heap->gc_cause(); | |
| 276 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 277 | |
| 278 // Check for potential problems. | |
| 279 if (!should_attempt_scavenge()) { | |
| 280 return false; | |
| 281 } | |
| 282 | |
| 283 bool promotion_failure_occurred = false; | |
| 284 | |
| 285 PSYoungGen* young_gen = heap->young_gen(); | |
| 286 PSOldGen* old_gen = heap->old_gen(); | |
| 287 PSAdaptiveSizePolicy* size_policy = heap->size_policy(); | |
| 288 heap->increment_total_collections(); | |
| 289 | |
| 290 AdaptiveSizePolicyOutput(size_policy, heap->total_collections()); | |
| 291 | |
| 292 if ((gc_cause != GCCause::_java_lang_system_gc) || | |
| 293 UseAdaptiveSizePolicyWithSystemGC) { | |
| 294 // Gather the feedback data for eden occupancy. | |
| 295 young_gen->eden_space()->accumulate_statistics(); | |
| 296 } | |
| 297 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
298 if (ZapUnusedHeapArea) { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
299 // Save information needed to minimize mangling |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
300 heap->record_gen_tops_before_GC(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
301 } |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
302 |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4095
diff
changeset
|
303 heap->print_heap_before_gc(); |
| 0 | 304 |
| 305 assert(!NeverTenure || _tenuring_threshold == markOopDesc::max_age + 1, "Sanity"); | |
| 306 assert(!AlwaysTenure || _tenuring_threshold == 0, "Sanity"); | |
| 307 | |
| 308 size_t prev_used = heap->used(); | |
| 309 assert(promotion_failed() == false, "Sanity"); | |
| 310 | |
| 311 // Fill in TLABs | |
| 312 heap->accumulate_statistics_all_tlabs(); | |
| 313 heap->ensure_parsability(true); // retire TLABs | |
| 314 | |
| 315 if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) { | |
| 316 HandleMark hm; // Discard invalid handles created during verification | |
| 317 gclog_or_tty->print(" VerifyBeforeGC:"); | |
|
6865
4202510ee0fe
8000831: Heap verification output incorrect/incomplete
johnc
parents:
6818
diff
changeset
|
318 Universe::verify(); |
| 0 | 319 } |
| 320 | |
| 321 { | |
| 322 ResourceMark rm; | |
| 323 HandleMark hm; | |
| 324 | |
| 325 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); | |
| 326 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); | |
|
6064
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
4913
diff
changeset
|
327 TraceTime t1(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, gclog_or_tty); |
| 0 | 328 TraceCollectorStats tcs(counters()); |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2379
diff
changeset
|
329 TraceMemoryManagerStats tms(false /* not full GC */,gc_cause); |
| 0 | 330 |
| 331 if (TraceGen0Time) accumulated_time()->start(); | |
| 332 | |
| 333 // Let the size policy know we're starting | |
| 334 size_policy->minor_collection_begin(); | |
| 335 | |
| 336 // Verify the object start arrays. | |
| 337 if (VerifyObjectStartArray && | |
| 338 VerifyBeforeGC) { | |
| 339 old_gen->verify_object_start_array(); | |
| 340 } | |
| 341 | |
| 342 // Verify no unmarked old->young roots | |
| 343 if (VerifyRememberedSets) { | |
| 344 CardTableExtension::verify_all_young_refs_imprecise(); | |
| 345 } | |
| 346 | |
| 347 if (!ScavengeWithObjectsInToSpace) { | |
| 348 assert(young_gen->to_space()->is_empty(), | |
| 349 "Attempt to scavenge with live objects in to_space"); | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
350 young_gen->to_space()->clear(SpaceDecorator::Mangle); |
| 0 | 351 } else if (ZapUnusedHeapArea) { |
| 352 young_gen->to_space()->mangle_unused_area(); | |
| 353 } | |
| 354 save_to_space_top_before_gc(); | |
| 355 | |
| 356 COMPILER2_PRESENT(DerivedPointerTable::clear()); | |
| 357 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3356
diff
changeset
|
358 reference_processor()->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/); |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
359 reference_processor()->setup_policy(false); |
| 0 | 360 |
| 361 // We track how much was promoted to the next generation for | |
| 362 // the AdaptiveSizePolicy. | |
| 363 size_t old_gen_used_before = old_gen->used_in_bytes(); | |
| 364 | |
| 365 // For PrintGCDetails | |
| 366 size_t young_gen_used_before = young_gen->used_in_bytes(); | |
| 367 | |
| 368 // Reset our survivor overflow. | |
| 369 set_survivor_overflow(false); | |
| 370 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
371 // We need to save the old top values before |
| 0 | 372 // creating the promotion_manager. We pass the top |
| 373 // values to the card_table, to prevent it from | |
| 374 // straying into the promotion labs. | |
| 375 HeapWord* old_top = old_gen->object_space()->top(); | |
| 376 | |
| 377 // Release all previously held resources | |
| 378 gc_task_manager()->release_all_resources(); | |
| 379 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
380 // Set the number of GC threads to be used in this collection |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
381 gc_task_manager()->set_active_gang(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
382 gc_task_manager()->task_idle_workers(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
383 // Get the active number of workers here and use that value |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
384 // throughout the methods. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
385 uint active_workers = gc_task_manager()->active_workers(); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
386 heap->set_par_threads(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
387 |
| 0 | 388 PSPromotionManager::pre_scavenge(); |
| 389 | |
| 390 // We'll use the promotion manager again later. | |
| 391 PSPromotionManager* promotion_manager = PSPromotionManager::vm_thread_promotion_manager(); | |
| 392 { | |
| 393 // TraceTime("Roots"); | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
394 ParallelScavengeHeap::ParStrongRootsScope psrs; |
| 0 | 395 |
| 396 GCTaskQueue* q = GCTaskQueue::create(); | |
| 397 | |
| 6817 | 398 if (!old_gen->object_space()->is_empty()) { |
| 399 // There are only old-to-young pointers if there are objects | |
| 400 // in the old gen. | |
| 401 uint stripe_total = active_workers; | |
| 402 for(uint i=0; i < stripe_total; i++) { | |
| 403 q->enqueue(new OldToYoungRootsTask(old_gen, old_top, i, stripe_total)); | |
| 404 } | |
| 0 | 405 } |
| 406 | |
| 407 q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::universe)); | |
| 408 q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jni_handles)); | |
| 409 // We scan the thread roots in parallel | |
| 410 Threads::create_thread_roots_tasks(q); | |
| 411 q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::object_synchronizer)); | |
| 412 q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::flat_profiler)); | |
| 413 q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::management)); | |
| 414 q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::system_dictionary)); | |
| 415 q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jvmti)); | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
579
diff
changeset
|
416 q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::code_cache)); |
| 0 | 417 |
| 418 ParallelTaskTerminator terminator( | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
419 active_workers, |
|
1706
9d7a8ab3736b
6962589: remove breadth first scanning code from parallel gc
tonyp
parents:
1638
diff
changeset
|
420 (TaskQueueSetSuper*) promotion_manager->stack_array_depth()); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
421 if (active_workers > 1) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
422 for (uint j = 0; j < active_workers; j++) { |
| 0 | 423 q->enqueue(new StealTask(&terminator)); |
| 424 } | |
| 425 } | |
| 426 | |
| 427 gc_task_manager()->execute_and_wait(q); | |
| 428 } | |
| 429 | |
| 430 scavenge_midpoint.update(); | |
| 431 | |
| 432 // Process reference objects discovered during scavenge | |
| 433 { | |
|
457
27a80744a83b
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
453
diff
changeset
|
434 reference_processor()->setup_policy(false); // not always_clear |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
435 reference_processor()->set_active_mt_degree(active_workers); |
| 0 | 436 PSKeepAliveClosure keep_alive(promotion_manager); |
| 437 PSEvacuateFollowersClosure evac_followers(promotion_manager); | |
| 438 if (reference_processor()->processing_is_mt()) { | |
| 439 PSRefProcTaskExecutor task_executor; | |
| 440 reference_processor()->process_discovered_references( | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
269
diff
changeset
|
441 &_is_alive_closure, &keep_alive, &evac_followers, &task_executor); |
| 0 | 442 } else { |
| 443 reference_processor()->process_discovered_references( | |
|
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
269
diff
changeset
|
444 &_is_alive_closure, &keep_alive, &evac_followers, NULL); |
| 0 | 445 } |
| 446 } | |
| 447 | |
| 448 // Enqueue reference objects discovered during scavenge. | |
| 449 if (reference_processor()->processing_is_mt()) { | |
| 450 PSRefProcTaskExecutor task_executor; | |
| 451 reference_processor()->enqueue_discovered_references(&task_executor); | |
| 452 } else { | |
| 453 reference_processor()->enqueue_discovered_references(NULL); | |
| 454 } | |
| 455 | |
|
2379
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
456 // Unlink any dead interned Strings |
|
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
457 StringTable::unlink(&_is_alive_closure); |
|
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
458 // Process the remaining live ones |
|
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
459 PSScavengeRootsClosure root_closure(promotion_manager); |
|
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
460 StringTable::oops_do(&root_closure); |
|
b099aaf51bf8
6962931: move interned strings out of the perm gen
jcoomes
parents:
2369
diff
changeset
|
461 |
| 0 | 462 // Finally, flush the promotion_manager's labs, and deallocate its stacks. |
| 463 PSPromotionManager::post_scavenge(); | |
| 464 | |
| 465 promotion_failure_occurred = promotion_failed(); | |
| 466 if (promotion_failure_occurred) { | |
| 467 clean_up_failed_promotion(); | |
| 468 if (PrintGC) { | |
| 469 gclog_or_tty->print("--"); | |
| 470 } | |
| 471 } | |
| 472 | |
| 473 // Let the size policy know we're done. Note that we count promotion | |
| 474 // failure cleanup time as part of the collection (otherwise, we're | |
| 475 // implicitly saying it's mutator time). | |
| 476 size_policy->minor_collection_end(gc_cause); | |
| 477 | |
| 478 if (!promotion_failure_occurred) { | |
| 479 // Swap the survivor spaces. | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
480 |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
481 |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
482 young_gen->eden_space()->clear(SpaceDecorator::Mangle); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
483 young_gen->from_space()->clear(SpaceDecorator::Mangle); |
| 0 | 484 young_gen->swap_spaces(); |
| 485 | |
| 486 size_t survived = young_gen->from_space()->used_in_bytes(); | |
| 487 size_t promoted = old_gen->used_in_bytes() - old_gen_used_before; | |
| 488 size_policy->update_averages(_survivor_overflow, survived, promoted); | |
| 489 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
490 // A successful scavenge should restart the GC time limit count which is |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
491 // for full GC's. |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
492 size_policy->reset_gc_overhead_limit_count(); |
| 0 | 493 if (UseAdaptiveSizePolicy) { |
| 494 // Calculate the new survivor size and tenuring threshold | |
| 495 | |
| 496 if (PrintAdaptiveSizePolicy) { | |
| 497 gclog_or_tty->print("AdaptiveSizeStart: "); | |
| 498 gclog_or_tty->stamp(); | |
| 499 gclog_or_tty->print_cr(" collection: %d ", | |
| 500 heap->total_collections()); | |
| 501 | |
| 502 if (Verbose) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
503 gclog_or_tty->print("old_gen_capacity: %d young_gen_capacity: %d", |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
504 old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes()); |
| 0 | 505 } |
| 506 } | |
| 507 | |
| 508 | |
| 509 if (UsePerfData) { | |
| 510 PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters(); | |
| 511 counters->update_old_eden_size( | |
| 512 size_policy->calculated_eden_size_in_bytes()); | |
| 513 counters->update_old_promo_size( | |
| 514 size_policy->calculated_promo_size_in_bytes()); | |
| 515 counters->update_old_capacity(old_gen->capacity_in_bytes()); | |
| 516 counters->update_young_capacity(young_gen->capacity_in_bytes()); | |
| 517 counters->update_survived(survived); | |
| 518 counters->update_promoted(promoted); | |
| 519 counters->update_survivor_overflowed(_survivor_overflow); | |
| 520 } | |
| 521 | |
| 522 size_t survivor_limit = | |
| 523 size_policy->max_survivor_size(young_gen->max_size()); | |
| 524 _tenuring_threshold = | |
| 525 size_policy->compute_survivor_space_size_and_threshold( | |
| 526 _survivor_overflow, | |
| 527 _tenuring_threshold, | |
| 528 survivor_limit); | |
| 529 | |
| 530 if (PrintTenuringDistribution) { | |
| 531 gclog_or_tty->cr(); | |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
6865
diff
changeset
|
532 gclog_or_tty->print_cr("Desired survivor size " SIZE_FORMAT " bytes, new threshold %u (max %u)", |
| 0 | 533 size_policy->calculated_survivor_size_in_bytes(), |
| 534 _tenuring_threshold, MaxTenuringThreshold); | |
| 535 } | |
| 536 | |
| 537 if (UsePerfData) { | |
| 538 PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters(); | |
| 539 counters->update_tenuring_threshold(_tenuring_threshold); | |
| 540 counters->update_survivor_size_counters(); | |
| 541 } | |
| 542 | |
| 543 // Do call at minor collections? | |
| 544 // Don't check if the size_policy is ready at this | |
| 545 // level. Let the size_policy check that internally. | |
| 546 if (UseAdaptiveSizePolicy && | |
| 547 UseAdaptiveGenerationSizePolicyAtMinorCollection && | |
| 548 ((gc_cause != GCCause::_java_lang_system_gc) || | |
| 549 UseAdaptiveSizePolicyWithSystemGC)) { | |
| 550 | |
| 551 // Calculate optimial free space amounts | |
| 552 assert(young_gen->max_size() > | |
| 553 young_gen->from_space()->capacity_in_bytes() + | |
| 554 young_gen->to_space()->capacity_in_bytes(), | |
| 555 "Sizes of space in young gen are out-of-bounds"); | |
| 556 size_t max_eden_size = young_gen->max_size() - | |
| 557 young_gen->from_space()->capacity_in_bytes() - | |
| 558 young_gen->to_space()->capacity_in_bytes(); | |
| 559 size_policy->compute_generation_free_space(young_gen->used_in_bytes(), | |
| 560 young_gen->eden_space()->used_in_bytes(), | |
| 561 old_gen->used_in_bytes(), | |
| 562 young_gen->eden_space()->capacity_in_bytes(), | |
| 563 old_gen->max_gen_size(), | |
| 564 max_eden_size, | |
| 565 false /* full gc*/, | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
566 gc_cause, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
989
diff
changeset
|
567 heap->collector_policy()); |
| 0 | 568 |
| 569 } | |
| 570 // Resize the young generation at every collection | |
| 571 // even if new sizes have not been calculated. This is | |
| 572 // to allow resizes that may have been inhibited by the | |
| 573 // relative location of the "to" and "from" spaces. | |
| 574 | |
| 575 // Resizing the old gen at minor collects can cause increases | |
| 576 // that don't feed back to the generation sizing policy until | |
| 577 // a major collection. Don't resize the old gen here. | |
| 578 | |
| 579 heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(), | |
| 580 size_policy->calculated_survivor_size_in_bytes()); | |
| 581 | |
| 582 if (PrintAdaptiveSizePolicy) { | |
| 583 gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ", | |
| 584 heap->total_collections()); | |
| 585 } | |
| 586 } | |
| 587 | |
| 588 // Update the structure of the eden. With NUMA-eden CPU hotplugging or offlining can | |
| 589 // cause the change of the heap layout. Make sure eden is reshaped if that's the case. | |
| 590 // Also update() will case adaptive NUMA chunk resizing. | |
| 591 assert(young_gen->eden_space()->is_empty(), "eden space should be empty now"); | |
| 592 young_gen->eden_space()->update(); | |
| 593 | |
| 594 heap->gc_policy_counters()->update_counters(); | |
| 595 | |
| 596 heap->resize_all_tlabs(); | |
| 597 | |
| 598 assert(young_gen->to_space()->is_empty(), "to space should be empty now"); | |
| 599 } | |
| 600 | |
| 601 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); | |
| 602 | |
| 603 NOT_PRODUCT(reference_processor()->verify_no_references_recorded()); | |
| 604 | |
| 4909 | 605 CodeCache::prune_scavenge_root_nmethods(); |
| 606 | |
| 0 | 607 // Re-verify object start arrays |
| 608 if (VerifyObjectStartArray && | |
| 609 VerifyAfterGC) { | |
| 610 old_gen->verify_object_start_array(); | |
| 611 } | |
| 612 | |
| 613 // Verify all old -> young cards are now precise | |
| 614 if (VerifyRememberedSets) { | |
| 615 // Precise verification will give false positives. Until this is fixed, | |
| 616 // use imprecise verification. | |
| 617 // CardTableExtension::verify_all_young_refs_precise(); | |
| 618 CardTableExtension::verify_all_young_refs_imprecise(); | |
| 619 } | |
| 620 | |
| 621 if (TraceGen0Time) accumulated_time()->stop(); | |
| 622 | |
| 623 if (PrintGC) { | |
| 624 if (PrintGCDetails) { | |
| 625 // Don't print a GC timestamp here. This is after the GC so | |
| 626 // would be confusing. | |
| 627 young_gen->print_used_change(young_gen_used_before); | |
| 628 } | |
| 629 heap->print_heap_change(prev_used); | |
| 630 } | |
| 631 | |
| 632 // Track memory usage and detect low memory | |
| 633 MemoryService::track_memory_usage(); | |
| 634 heap->update_counters(); | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
635 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
636 gc_task_manager()->release_idle_workers(); |
| 0 | 637 } |
| 638 | |
| 639 if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) { | |
| 640 HandleMark hm; // Discard invalid handles created during verification | |
| 641 gclog_or_tty->print(" VerifyAfterGC:"); | |
|
6865
4202510ee0fe
8000831: Heap verification output incorrect/incomplete
johnc
parents:
6818
diff
changeset
|
642 Universe::verify(); |
| 0 | 643 } |
| 644 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4095
diff
changeset
|
645 heap->print_heap_after_gc(); |
| 0 | 646 |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
647 if (ZapUnusedHeapArea) { |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
648 young_gen->eden_space()->check_mangled_unused_area_complete(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
649 young_gen->from_space()->check_mangled_unused_area_complete(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
650 young_gen->to_space()->check_mangled_unused_area_complete(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
651 } |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
652 |
| 0 | 653 scavenge_exit.update(); |
| 654 | |
| 655 if (PrintGCTaskTimeStamps) { | |
| 656 tty->print_cr("VM-Thread " INT64_FORMAT " " INT64_FORMAT " " INT64_FORMAT, | |
| 657 scavenge_entry.ticks(), scavenge_midpoint.ticks(), | |
| 658 scavenge_exit.ticks()); | |
| 659 gc_task_manager()->print_task_time_stamps(); | |
| 660 } | |
| 661 | |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
457
diff
changeset
|
662 #ifdef TRACESPINNING |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
457
diff
changeset
|
663 ParallelTaskTerminator::print_termination_counts(); |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
457
diff
changeset
|
664 #endif |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
457
diff
changeset
|
665 |
| 0 | 666 return !promotion_failure_occurred; |
| 667 } | |
| 668 | |
| 669 // This method iterates over all objects in the young generation, | |
| 670 // unforwarding markOops. It then restores any preserved mark oops, | |
| 671 // and clears the _preserved_mark_stack. | |
| 672 void PSScavenge::clean_up_failed_promotion() { | |
| 673 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 674 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 675 assert(promotion_failed(), "Sanity"); | |
| 676 | |
| 677 PSYoungGen* young_gen = heap->young_gen(); | |
| 678 | |
| 679 { | |
| 680 ResourceMark rm; | |
| 681 | |
| 682 // Unforward all pointers in the young gen. | |
| 683 PSPromotionFailedClosure unforward_closure; | |
| 684 young_gen->object_iterate(&unforward_closure); | |
| 685 | |
| 686 if (PrintGC && Verbose) { | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
687 gclog_or_tty->print_cr("Restoring %d marks", _preserved_oop_stack.size()); |
| 0 | 688 } |
| 689 | |
| 690 // Restore any saved marks. | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
691 while (!_preserved_oop_stack.is_empty()) { |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
692 oop obj = _preserved_oop_stack.pop(); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
693 markOop mark = _preserved_mark_stack.pop(); |
| 0 | 694 obj->set_mark(mark); |
| 695 } | |
| 696 | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
697 // Clear the preserved mark and oop stack caches. |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
698 _preserved_mark_stack.clear(true); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
699 _preserved_oop_stack.clear(true); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
700 _promotion_failed = false; |
| 0 | 701 } |
| 702 | |
| 703 // Reset the PromotionFailureALot counters. | |
| 704 NOT_PRODUCT(Universe::heap()->reset_promotion_should_fail();) | |
| 705 } | |
| 706 | |
| 707 // This method is called whenever an attempt to promote an object | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
708 // fails. Some markOops will need preservation, some will not. Note |
| 0 | 709 // that the entire eden is traversed after a failed promotion, with |
| 710 // all forwarded headers replaced by the default markOop. This means | |
| 711 // it is not neccessary to preserve most markOops. | |
| 712 void PSScavenge::oop_promotion_failed(oop obj, markOop obj_mark) { | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
713 _promotion_failed = true; |
| 0 | 714 if (obj_mark->must_be_preserved_for_promotion_failure(obj)) { |
|
2038
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
1972
diff
changeset
|
715 // Should use per-worker private stakcs hetre rather than |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
1972
diff
changeset
|
716 // locking a common pair of stacks. |
| 0 | 717 ThreadCritical tc; |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
718 _preserved_oop_stack.push(obj); |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1706
diff
changeset
|
719 _preserved_mark_stack.push(obj_mark); |
| 0 | 720 } |
| 721 } | |
| 722 | |
| 723 bool PSScavenge::should_attempt_scavenge() { | |
| 724 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 725 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 726 PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters(); | |
| 727 | |
| 728 if (UsePerfData) { | |
| 729 counters->update_scavenge_skipped(not_skipped); | |
| 730 } | |
| 731 | |
| 732 PSYoungGen* young_gen = heap->young_gen(); | |
| 733 PSOldGen* old_gen = heap->old_gen(); | |
| 734 | |
| 735 if (!ScavengeWithObjectsInToSpace) { | |
| 736 // Do not attempt to promote unless to_space is empty | |
| 737 if (!young_gen->to_space()->is_empty()) { | |
| 738 _consecutive_skipped_scavenges++; | |
| 739 if (UsePerfData) { | |
| 740 counters->update_scavenge_skipped(to_space_not_empty); | |
| 741 } | |
| 742 return false; | |
| 743 } | |
| 744 } | |
| 745 | |
| 746 // Test to see if the scavenge will likely fail. | |
| 747 PSAdaptiveSizePolicy* policy = heap->size_policy(); | |
| 748 | |
| 749 // A similar test is done in the policy's should_full_GC(). If this is | |
| 750 // changed, decide if that test should also be changed. | |
| 751 size_t avg_promoted = (size_t) policy->padded_average_promoted_in_bytes(); | |
| 752 size_t promotion_estimate = MIN2(avg_promoted, young_gen->used_in_bytes()); | |
| 753 bool result = promotion_estimate < old_gen->free_in_bytes(); | |
| 754 | |
| 755 if (PrintGCDetails && Verbose) { | |
| 756 gclog_or_tty->print(result ? " do scavenge: " : " skip scavenge: "); | |
| 757 gclog_or_tty->print_cr(" average_promoted " SIZE_FORMAT | |
| 758 " padded_average_promoted " SIZE_FORMAT | |
| 759 " free in old gen " SIZE_FORMAT, | |
| 760 (size_t) policy->average_promoted_in_bytes(), | |
| 761 (size_t) policy->padded_average_promoted_in_bytes(), | |
| 762 old_gen->free_in_bytes()); | |
| 763 if (young_gen->used_in_bytes() < | |
| 764 (size_t) policy->padded_average_promoted_in_bytes()) { | |
| 765 gclog_or_tty->print_cr(" padded_promoted_average is greater" | |
| 766 " than maximum promotion = " SIZE_FORMAT, young_gen->used_in_bytes()); | |
| 767 } | |
| 768 } | |
| 769 | |
| 770 if (result) { | |
| 771 _consecutive_skipped_scavenges = 0; | |
| 772 } else { | |
| 773 _consecutive_skipped_scavenges++; | |
| 774 if (UsePerfData) { | |
| 775 counters->update_scavenge_skipped(promoted_too_large); | |
| 776 } | |
| 777 } | |
| 778 return result; | |
| 779 } | |
| 780 | |
| 781 // Used to add tasks | |
| 782 GCTaskManager* const PSScavenge::gc_task_manager() { | |
| 783 assert(ParallelScavengeHeap::gc_task_manager() != NULL, | |
| 784 "shouldn't return NULL"); | |
| 785 return ParallelScavengeHeap::gc_task_manager(); | |
| 786 } | |
| 787 | |
| 788 void PSScavenge::initialize() { | |
| 789 // Arguments must have been parsed | |
| 790 | |
| 791 if (AlwaysTenure) { | |
| 792 _tenuring_threshold = 0; | |
| 793 } else if (NeverTenure) { | |
| 794 _tenuring_threshold = markOopDesc::max_age + 1; | |
| 795 } else { | |
| 796 // We want to smooth out our startup times for the AdaptiveSizePolicy | |
| 797 _tenuring_threshold = (UseAdaptiveSizePolicy) ? InitialTenuringThreshold : | |
| 798 MaxTenuringThreshold; | |
| 799 } | |
| 800 | |
| 801 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); | |
| 802 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); | |
| 803 | |
| 804 PSYoungGen* young_gen = heap->young_gen(); | |
| 805 PSOldGen* old_gen = heap->old_gen(); | |
| 806 | |
| 807 // Set boundary between young_gen and old_gen | |
| 808 assert(old_gen->reserved().end() <= young_gen->eden_space()->bottom(), | |
| 809 "old above young"); | |
| 810 _young_generation_boundary = young_gen->eden_space()->bottom(); | |
| 811 | |
| 812 // Initialize ref handling object for scavenging. | |
| 813 MemRegion mr = young_gen->reserved(); | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
814 |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2038
diff
changeset
|
815 _ref_processor = |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2038
diff
changeset
|
816 new ReferenceProcessor(mr, // span |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2038
diff
changeset
|
817 ParallelRefProcEnabled && (ParallelGCThreads > 1), // mt processing |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2038
diff
changeset
|
818 (int) ParallelGCThreads, // mt processing degree |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2038
diff
changeset
|
819 true, // mt discovery |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2038
diff
changeset
|
820 (int) ParallelGCThreads, // mt discovery degree |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2038
diff
changeset
|
821 true, // atomic_discovery |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2038
diff
changeset
|
822 NULL, // header provides liveness info |
|
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2038
diff
changeset
|
823 false); // next field updates do not need write barrier |
| 0 | 824 |
| 825 // Cache the cardtable | |
| 826 BarrierSet* bs = Universe::heap()->barrier_set(); | |
| 827 assert(bs->kind() == BarrierSet::CardTableModRef, "Wrong barrier set kind"); | |
| 828 _card_table = (CardTableExtension*)bs; | |
| 829 | |
| 830 _counters = new CollectorCounters("PSScavenge", 0); | |
| 831 } |