Thu, 01 Jul 2010 21:40:45 -0700
6957084: simplify TaskQueue overflow handling
Reviewed-by: ysr, jmasa
duke@435 | 1 | /* |
trims@1907 | 2 | * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. |
duke@435 | 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
duke@435 | 4 | * |
duke@435 | 5 | * This code is free software; you can redistribute it and/or modify it |
duke@435 | 6 | * under the terms of the GNU General Public License version 2 only, as |
duke@435 | 7 | * published by the Free Software Foundation. |
duke@435 | 8 | * |
duke@435 | 9 | * This code is distributed in the hope that it will be useful, but WITHOUT |
duke@435 | 10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
duke@435 | 11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
duke@435 | 12 | * version 2 for more details (a copy is included in the LICENSE file that |
duke@435 | 13 | * accompanied this code). |
duke@435 | 14 | * |
duke@435 | 15 | * You should have received a copy of the GNU General Public License version |
duke@435 | 16 | * 2 along with this work; if not, write to the Free Software Foundation, |
duke@435 | 17 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
duke@435 | 18 | * |
trims@1907 | 19 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
trims@1907 | 20 | * or visit www.oracle.com if you need additional information or have any |
trims@1907 | 21 | * questions. |
duke@435 | 22 | * |
duke@435 | 23 | */ |
duke@435 | 24 | |
duke@435 | 25 | |
duke@435 | 26 | # include "incls/_precompiled.incl" |
duke@435 | 27 | # include "incls/_psScavenge.cpp.incl" |
duke@435 | 28 | |
duke@435 | 29 | HeapWord* PSScavenge::_to_space_top_before_gc = NULL; |
duke@435 | 30 | int PSScavenge::_consecutive_skipped_scavenges = 0; |
duke@435 | 31 | ReferenceProcessor* PSScavenge::_ref_processor = NULL; |
duke@435 | 32 | CardTableExtension* PSScavenge::_card_table = NULL; |
duke@435 | 33 | bool PSScavenge::_survivor_overflow = false; |
duke@435 | 34 | int PSScavenge::_tenuring_threshold = 0; |
duke@435 | 35 | HeapWord* PSScavenge::_young_generation_boundary = NULL; |
duke@435 | 36 | elapsedTimer PSScavenge::_accumulated_time; |
duke@435 | 37 | GrowableArray<markOop>* PSScavenge::_preserved_mark_stack = NULL; |
duke@435 | 38 | GrowableArray<oop>* PSScavenge::_preserved_oop_stack = NULL; |
duke@435 | 39 | CollectorCounters* PSScavenge::_counters = NULL; |
duke@435 | 40 | |
duke@435 | 41 | // Define before use |
duke@435 | 42 | class PSIsAliveClosure: public BoolObjectClosure { |
duke@435 | 43 | public: |
duke@435 | 44 | void do_object(oop p) { |
duke@435 | 45 | assert(false, "Do not call."); |
duke@435 | 46 | } |
duke@435 | 47 | bool do_object_b(oop p) { |
duke@435 | 48 | return (!PSScavenge::is_obj_in_young((HeapWord*) p)) || p->is_forwarded(); |
duke@435 | 49 | } |
duke@435 | 50 | }; |
duke@435 | 51 | |
duke@435 | 52 | PSIsAliveClosure PSScavenge::_is_alive_closure; |
duke@435 | 53 | |
duke@435 | 54 | class PSKeepAliveClosure: public OopClosure { |
duke@435 | 55 | protected: |
duke@435 | 56 | MutableSpace* _to_space; |
duke@435 | 57 | PSPromotionManager* _promotion_manager; |
duke@435 | 58 | |
duke@435 | 59 | public: |
duke@435 | 60 | PSKeepAliveClosure(PSPromotionManager* pm) : _promotion_manager(pm) { |
duke@435 | 61 | ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); |
duke@435 | 62 | assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); |
duke@435 | 63 | _to_space = heap->young_gen()->to_space(); |
duke@435 | 64 | |
duke@435 | 65 | assert(_promotion_manager != NULL, "Sanity"); |
duke@435 | 66 | } |
duke@435 | 67 | |
coleenp@548 | 68 | template <class T> void do_oop_work(T* p) { |
coleenp@548 | 69 | assert (!oopDesc::is_null(*p), "expected non-null ref"); |
coleenp@548 | 70 | assert ((oopDesc::load_decode_heap_oop_not_null(p))->is_oop(), |
coleenp@548 | 71 | "expected an oop while scanning weak refs"); |
duke@435 | 72 | |
duke@435 | 73 | // Weak refs may be visited more than once. |
coleenp@548 | 74 | if (PSScavenge::should_scavenge(p, _to_space)) { |
duke@435 | 75 | PSScavenge::copy_and_push_safe_barrier(_promotion_manager, p); |
duke@435 | 76 | } |
duke@435 | 77 | } |
coleenp@548 | 78 | virtual void do_oop(oop* p) { PSKeepAliveClosure::do_oop_work(p); } |
coleenp@548 | 79 | virtual void do_oop(narrowOop* p) { PSKeepAliveClosure::do_oop_work(p); } |
duke@435 | 80 | }; |
duke@435 | 81 | |
duke@435 | 82 | class PSEvacuateFollowersClosure: public VoidClosure { |
duke@435 | 83 | private: |
duke@435 | 84 | PSPromotionManager* _promotion_manager; |
duke@435 | 85 | public: |
duke@435 | 86 | PSEvacuateFollowersClosure(PSPromotionManager* pm) : _promotion_manager(pm) {} |
duke@435 | 87 | |
coleenp@548 | 88 | virtual void do_void() { |
duke@435 | 89 | assert(_promotion_manager != NULL, "Sanity"); |
duke@435 | 90 | _promotion_manager->drain_stacks(true); |
duke@435 | 91 | guarantee(_promotion_manager->stacks_empty(), |
duke@435 | 92 | "stacks should be empty at this point"); |
duke@435 | 93 | } |
duke@435 | 94 | }; |
duke@435 | 95 | |
duke@435 | 96 | class PSPromotionFailedClosure : public ObjectClosure { |
duke@435 | 97 | virtual void do_object(oop obj) { |
duke@435 | 98 | if (obj->is_forwarded()) { |
duke@435 | 99 | obj->init_mark(); |
duke@435 | 100 | } |
duke@435 | 101 | } |
duke@435 | 102 | }; |
duke@435 | 103 | |
duke@435 | 104 | class PSRefProcTaskProxy: public GCTask { |
duke@435 | 105 | typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; |
duke@435 | 106 | ProcessTask & _rp_task; |
duke@435 | 107 | uint _work_id; |
duke@435 | 108 | public: |
duke@435 | 109 | PSRefProcTaskProxy(ProcessTask & rp_task, uint work_id) |
duke@435 | 110 | : _rp_task(rp_task), |
duke@435 | 111 | _work_id(work_id) |
duke@435 | 112 | { } |
duke@435 | 113 | |
duke@435 | 114 | private: |
duke@435 | 115 | virtual char* name() { return (char *)"Process referents by policy in parallel"; } |
duke@435 | 116 | virtual void do_it(GCTaskManager* manager, uint which); |
duke@435 | 117 | }; |
duke@435 | 118 | |
duke@435 | 119 | void PSRefProcTaskProxy::do_it(GCTaskManager* manager, uint which) |
duke@435 | 120 | { |
duke@435 | 121 | PSPromotionManager* promotion_manager = |
duke@435 | 122 | PSPromotionManager::gc_thread_promotion_manager(which); |
duke@435 | 123 | assert(promotion_manager != NULL, "sanity check"); |
duke@435 | 124 | PSKeepAliveClosure keep_alive(promotion_manager); |
duke@435 | 125 | PSEvacuateFollowersClosure evac_followers(promotion_manager); |
duke@435 | 126 | PSIsAliveClosure is_alive; |
duke@435 | 127 | _rp_task.work(_work_id, is_alive, keep_alive, evac_followers); |
duke@435 | 128 | } |
duke@435 | 129 | |
duke@435 | 130 | class PSRefEnqueueTaskProxy: public GCTask { |
duke@435 | 131 | typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask; |
duke@435 | 132 | EnqueueTask& _enq_task; |
duke@435 | 133 | uint _work_id; |
duke@435 | 134 | |
duke@435 | 135 | public: |
duke@435 | 136 | PSRefEnqueueTaskProxy(EnqueueTask& enq_task, uint work_id) |
duke@435 | 137 | : _enq_task(enq_task), |
duke@435 | 138 | _work_id(work_id) |
duke@435 | 139 | { } |
duke@435 | 140 | |
duke@435 | 141 | virtual char* name() { return (char *)"Enqueue reference objects in parallel"; } |
duke@435 | 142 | virtual void do_it(GCTaskManager* manager, uint which) |
duke@435 | 143 | { |
duke@435 | 144 | _enq_task.work(_work_id); |
duke@435 | 145 | } |
duke@435 | 146 | }; |
duke@435 | 147 | |
duke@435 | 148 | class PSRefProcTaskExecutor: public AbstractRefProcTaskExecutor { |
duke@435 | 149 | virtual void execute(ProcessTask& task); |
duke@435 | 150 | virtual void execute(EnqueueTask& task); |
duke@435 | 151 | }; |
duke@435 | 152 | |
duke@435 | 153 | void PSRefProcTaskExecutor::execute(ProcessTask& task) |
duke@435 | 154 | { |
duke@435 | 155 | GCTaskQueue* q = GCTaskQueue::create(); |
duke@435 | 156 | for(uint i=0; i<ParallelGCThreads; i++) { |
duke@435 | 157 | q->enqueue(new PSRefProcTaskProxy(task, i)); |
duke@435 | 158 | } |
duke@435 | 159 | ParallelTaskTerminator terminator( |
duke@435 | 160 | ParallelScavengeHeap::gc_task_manager()->workers(), |
duke@435 | 161 | UseDepthFirstScavengeOrder ? |
duke@435 | 162 | (TaskQueueSetSuper*) PSPromotionManager::stack_array_depth() |
duke@435 | 163 | : (TaskQueueSetSuper*) PSPromotionManager::stack_array_breadth()); |
duke@435 | 164 | if (task.marks_oops_alive() && ParallelGCThreads > 1) { |
duke@435 | 165 | for (uint j=0; j<ParallelGCThreads; j++) { |
duke@435 | 166 | q->enqueue(new StealTask(&terminator)); |
duke@435 | 167 | } |
duke@435 | 168 | } |
duke@435 | 169 | ParallelScavengeHeap::gc_task_manager()->execute_and_wait(q); |
duke@435 | 170 | } |
duke@435 | 171 | |
duke@435 | 172 | |
duke@435 | 173 | void PSRefProcTaskExecutor::execute(EnqueueTask& task) |
duke@435 | 174 | { |
duke@435 | 175 | GCTaskQueue* q = GCTaskQueue::create(); |
duke@435 | 176 | for(uint i=0; i<ParallelGCThreads; i++) { |
duke@435 | 177 | q->enqueue(new PSRefEnqueueTaskProxy(task, i)); |
duke@435 | 178 | } |
duke@435 | 179 | ParallelScavengeHeap::gc_task_manager()->execute_and_wait(q); |
duke@435 | 180 | } |
duke@435 | 181 | |
duke@435 | 182 | // This method contains all heap specific policy for invoking scavenge. |
duke@435 | 183 | // PSScavenge::invoke_no_policy() will do nothing but attempt to |
duke@435 | 184 | // scavenge. It will not clean up after failed promotions, bail out if |
duke@435 | 185 | // we've exceeded policy time limits, or any other special behavior. |
duke@435 | 186 | // All such policy should be placed here. |
duke@435 | 187 | // |
duke@435 | 188 | // Note that this method should only be called from the vm_thread while |
duke@435 | 189 | // at a safepoint! |
jmasa@1822 | 190 | void PSScavenge::invoke() { |
duke@435 | 191 | assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); |
duke@435 | 192 | assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread"); |
duke@435 | 193 | assert(!Universe::heap()->is_gc_active(), "not reentrant"); |
duke@435 | 194 | |
duke@435 | 195 | ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); |
duke@435 | 196 | assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); |
duke@435 | 197 | |
duke@435 | 198 | PSAdaptiveSizePolicy* policy = heap->size_policy(); |
jmasa@1822 | 199 | IsGCActiveMark mark; |
duke@435 | 200 | |
jmasa@1822 | 201 | bool scavenge_was_done = PSScavenge::invoke_no_policy(); |
duke@435 | 202 | |
jmasa@1822 | 203 | PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters(); |
jmasa@1822 | 204 | if (UsePerfData) |
jmasa@1822 | 205 | counters->update_full_follows_scavenge(0); |
jmasa@1822 | 206 | if (!scavenge_was_done || |
jmasa@1822 | 207 | policy->should_full_GC(heap->old_gen()->free_in_bytes())) { |
jmasa@1822 | 208 | if (UsePerfData) |
jmasa@1822 | 209 | counters->update_full_follows_scavenge(full_follows_scavenge); |
jmasa@1822 | 210 | GCCauseSetter gccs(heap, GCCause::_adaptive_size_policy); |
jmasa@1822 | 211 | CollectorPolicy* cp = heap->collector_policy(); |
jmasa@1822 | 212 | const bool clear_all_softrefs = cp->should_clear_all_soft_refs(); |
duke@435 | 213 | |
jmasa@1822 | 214 | if (UseParallelOldGC) { |
jmasa@1822 | 215 | PSParallelCompact::invoke_no_policy(clear_all_softrefs); |
jmasa@1822 | 216 | } else { |
jmasa@1822 | 217 | PSMarkSweep::invoke_no_policy(clear_all_softrefs); |
duke@435 | 218 | } |
duke@435 | 219 | } |
duke@435 | 220 | } |
duke@435 | 221 | |
duke@435 | 222 | // This method contains no policy. You should probably |
duke@435 | 223 | // be calling invoke() instead. |
duke@435 | 224 | bool PSScavenge::invoke_no_policy() { |
duke@435 | 225 | assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); |
duke@435 | 226 | assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread"); |
duke@435 | 227 | |
duke@435 | 228 | TimeStamp scavenge_entry; |
duke@435 | 229 | TimeStamp scavenge_midpoint; |
duke@435 | 230 | TimeStamp scavenge_exit; |
duke@435 | 231 | |
duke@435 | 232 | scavenge_entry.update(); |
duke@435 | 233 | |
duke@435 | 234 | if (GC_locker::check_active_before_gc()) { |
duke@435 | 235 | return false; |
duke@435 | 236 | } |
duke@435 | 237 | |
duke@435 | 238 | ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); |
duke@435 | 239 | GCCause::Cause gc_cause = heap->gc_cause(); |
duke@435 | 240 | assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); |
duke@435 | 241 | |
duke@435 | 242 | // Check for potential problems. |
duke@435 | 243 | if (!should_attempt_scavenge()) { |
duke@435 | 244 | return false; |
duke@435 | 245 | } |
duke@435 | 246 | |
duke@435 | 247 | bool promotion_failure_occurred = false; |
duke@435 | 248 | |
duke@435 | 249 | PSYoungGen* young_gen = heap->young_gen(); |
duke@435 | 250 | PSOldGen* old_gen = heap->old_gen(); |
duke@435 | 251 | PSPermGen* perm_gen = heap->perm_gen(); |
duke@435 | 252 | PSAdaptiveSizePolicy* size_policy = heap->size_policy(); |
duke@435 | 253 | heap->increment_total_collections(); |
duke@435 | 254 | |
duke@435 | 255 | AdaptiveSizePolicyOutput(size_policy, heap->total_collections()); |
duke@435 | 256 | |
duke@435 | 257 | if ((gc_cause != GCCause::_java_lang_system_gc) || |
duke@435 | 258 | UseAdaptiveSizePolicyWithSystemGC) { |
duke@435 | 259 | // Gather the feedback data for eden occupancy. |
duke@435 | 260 | young_gen->eden_space()->accumulate_statistics(); |
duke@435 | 261 | } |
duke@435 | 262 | |
jmasa@698 | 263 | if (ZapUnusedHeapArea) { |
jmasa@698 | 264 | // Save information needed to minimize mangling |
jmasa@698 | 265 | heap->record_gen_tops_before_GC(); |
jmasa@698 | 266 | } |
jmasa@698 | 267 | |
duke@435 | 268 | if (PrintHeapAtGC) { |
duke@435 | 269 | Universe::print_heap_before_gc(); |
duke@435 | 270 | } |
duke@435 | 271 | |
duke@435 | 272 | assert(!NeverTenure || _tenuring_threshold == markOopDesc::max_age + 1, "Sanity"); |
duke@435 | 273 | assert(!AlwaysTenure || _tenuring_threshold == 0, "Sanity"); |
duke@435 | 274 | |
duke@435 | 275 | size_t prev_used = heap->used(); |
duke@435 | 276 | assert(promotion_failed() == false, "Sanity"); |
duke@435 | 277 | |
duke@435 | 278 | // Fill in TLABs |
duke@435 | 279 | heap->accumulate_statistics_all_tlabs(); |
duke@435 | 280 | heap->ensure_parsability(true); // retire TLABs |
duke@435 | 281 | |
duke@435 | 282 | if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) { |
duke@435 | 283 | HandleMark hm; // Discard invalid handles created during verification |
duke@435 | 284 | gclog_or_tty->print(" VerifyBeforeGC:"); |
duke@435 | 285 | Universe::verify(true); |
duke@435 | 286 | } |
duke@435 | 287 | |
duke@435 | 288 | { |
duke@435 | 289 | ResourceMark rm; |
duke@435 | 290 | HandleMark hm; |
duke@435 | 291 | |
duke@435 | 292 | gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps); |
duke@435 | 293 | TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); |
duke@435 | 294 | TraceTime t1("GC", PrintGC, !PrintGCDetails, gclog_or_tty); |
duke@435 | 295 | TraceCollectorStats tcs(counters()); |
duke@435 | 296 | TraceMemoryManagerStats tms(false /* not full GC */); |
duke@435 | 297 | |
duke@435 | 298 | if (TraceGen0Time) accumulated_time()->start(); |
duke@435 | 299 | |
duke@435 | 300 | // Let the size policy know we're starting |
duke@435 | 301 | size_policy->minor_collection_begin(); |
duke@435 | 302 | |
duke@435 | 303 | // Verify the object start arrays. |
duke@435 | 304 | if (VerifyObjectStartArray && |
duke@435 | 305 | VerifyBeforeGC) { |
duke@435 | 306 | old_gen->verify_object_start_array(); |
duke@435 | 307 | perm_gen->verify_object_start_array(); |
duke@435 | 308 | } |
duke@435 | 309 | |
duke@435 | 310 | // Verify no unmarked old->young roots |
duke@435 | 311 | if (VerifyRememberedSets) { |
duke@435 | 312 | CardTableExtension::verify_all_young_refs_imprecise(); |
duke@435 | 313 | } |
duke@435 | 314 | |
duke@435 | 315 | if (!ScavengeWithObjectsInToSpace) { |
duke@435 | 316 | assert(young_gen->to_space()->is_empty(), |
duke@435 | 317 | "Attempt to scavenge with live objects in to_space"); |
jmasa@698 | 318 | young_gen->to_space()->clear(SpaceDecorator::Mangle); |
duke@435 | 319 | } else if (ZapUnusedHeapArea) { |
duke@435 | 320 | young_gen->to_space()->mangle_unused_area(); |
duke@435 | 321 | } |
duke@435 | 322 | save_to_space_top_before_gc(); |
duke@435 | 323 | |
duke@435 | 324 | NOT_PRODUCT(reference_processor()->verify_no_references_recorded()); |
duke@435 | 325 | COMPILER2_PRESENT(DerivedPointerTable::clear()); |
duke@435 | 326 | |
duke@435 | 327 | reference_processor()->enable_discovery(); |
ysr@892 | 328 | reference_processor()->setup_policy(false); |
duke@435 | 329 | |
duke@435 | 330 | // We track how much was promoted to the next generation for |
duke@435 | 331 | // the AdaptiveSizePolicy. |
duke@435 | 332 | size_t old_gen_used_before = old_gen->used_in_bytes(); |
duke@435 | 333 | |
duke@435 | 334 | // For PrintGCDetails |
duke@435 | 335 | size_t young_gen_used_before = young_gen->used_in_bytes(); |
duke@435 | 336 | |
duke@435 | 337 | // Reset our survivor overflow. |
duke@435 | 338 | set_survivor_overflow(false); |
duke@435 | 339 | |
duke@435 | 340 | // We need to save the old/perm top values before |
duke@435 | 341 | // creating the promotion_manager. We pass the top |
duke@435 | 342 | // values to the card_table, to prevent it from |
duke@435 | 343 | // straying into the promotion labs. |
duke@435 | 344 | HeapWord* old_top = old_gen->object_space()->top(); |
duke@435 | 345 | HeapWord* perm_top = perm_gen->object_space()->top(); |
duke@435 | 346 | |
duke@435 | 347 | // Release all previously held resources |
duke@435 | 348 | gc_task_manager()->release_all_resources(); |
duke@435 | 349 | |
duke@435 | 350 | PSPromotionManager::pre_scavenge(); |
duke@435 | 351 | |
duke@435 | 352 | // We'll use the promotion manager again later. |
duke@435 | 353 | PSPromotionManager* promotion_manager = PSPromotionManager::vm_thread_promotion_manager(); |
duke@435 | 354 | { |
duke@435 | 355 | // TraceTime("Roots"); |
jrose@1424 | 356 | ParallelScavengeHeap::ParStrongRootsScope psrs; |
duke@435 | 357 | |
duke@435 | 358 | GCTaskQueue* q = GCTaskQueue::create(); |
duke@435 | 359 | |
duke@435 | 360 | for(uint i=0; i<ParallelGCThreads; i++) { |
duke@435 | 361 | q->enqueue(new OldToYoungRootsTask(old_gen, old_top, i)); |
duke@435 | 362 | } |
duke@435 | 363 | |
duke@435 | 364 | q->enqueue(new SerialOldToYoungRootsTask(perm_gen, perm_top)); |
duke@435 | 365 | |
duke@435 | 366 | q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::universe)); |
duke@435 | 367 | q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jni_handles)); |
duke@435 | 368 | // We scan the thread roots in parallel |
duke@435 | 369 | Threads::create_thread_roots_tasks(q); |
duke@435 | 370 | q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::object_synchronizer)); |
duke@435 | 371 | q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::flat_profiler)); |
duke@435 | 372 | q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::management)); |
duke@435 | 373 | q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::system_dictionary)); |
duke@435 | 374 | q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jvmti)); |
jrose@1424 | 375 | q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::code_cache)); |
duke@435 | 376 | |
duke@435 | 377 | ParallelTaskTerminator terminator( |
duke@435 | 378 | gc_task_manager()->workers(), |
duke@435 | 379 | promotion_manager->depth_first() ? |
duke@435 | 380 | (TaskQueueSetSuper*) promotion_manager->stack_array_depth() |
duke@435 | 381 | : (TaskQueueSetSuper*) promotion_manager->stack_array_breadth()); |
duke@435 | 382 | if (ParallelGCThreads>1) { |
duke@435 | 383 | for (uint j=0; j<ParallelGCThreads; j++) { |
duke@435 | 384 | q->enqueue(new StealTask(&terminator)); |
duke@435 | 385 | } |
duke@435 | 386 | } |
duke@435 | 387 | |
duke@435 | 388 | gc_task_manager()->execute_and_wait(q); |
duke@435 | 389 | } |
duke@435 | 390 | |
duke@435 | 391 | scavenge_midpoint.update(); |
duke@435 | 392 | |
duke@435 | 393 | // Process reference objects discovered during scavenge |
duke@435 | 394 | { |
ysr@892 | 395 | reference_processor()->setup_policy(false); // not always_clear |
duke@435 | 396 | PSKeepAliveClosure keep_alive(promotion_manager); |
duke@435 | 397 | PSEvacuateFollowersClosure evac_followers(promotion_manager); |
duke@435 | 398 | if (reference_processor()->processing_is_mt()) { |
duke@435 | 399 | PSRefProcTaskExecutor task_executor; |
duke@435 | 400 | reference_processor()->process_discovered_references( |
ysr@888 | 401 | &_is_alive_closure, &keep_alive, &evac_followers, &task_executor); |
duke@435 | 402 | } else { |
duke@435 | 403 | reference_processor()->process_discovered_references( |
ysr@888 | 404 | &_is_alive_closure, &keep_alive, &evac_followers, NULL); |
duke@435 | 405 | } |
duke@435 | 406 | } |
duke@435 | 407 | |
duke@435 | 408 | // Enqueue reference objects discovered during scavenge. |
duke@435 | 409 | if (reference_processor()->processing_is_mt()) { |
duke@435 | 410 | PSRefProcTaskExecutor task_executor; |
duke@435 | 411 | reference_processor()->enqueue_discovered_references(&task_executor); |
duke@435 | 412 | } else { |
duke@435 | 413 | reference_processor()->enqueue_discovered_references(NULL); |
duke@435 | 414 | } |
duke@435 | 415 | |
duke@435 | 416 | // Finally, flush the promotion_manager's labs, and deallocate its stacks. |
duke@435 | 417 | PSPromotionManager::post_scavenge(); |
duke@435 | 418 | |
duke@435 | 419 | promotion_failure_occurred = promotion_failed(); |
duke@435 | 420 | if (promotion_failure_occurred) { |
duke@435 | 421 | clean_up_failed_promotion(); |
duke@435 | 422 | if (PrintGC) { |
duke@435 | 423 | gclog_or_tty->print("--"); |
duke@435 | 424 | } |
duke@435 | 425 | } |
duke@435 | 426 | |
duke@435 | 427 | // Let the size policy know we're done. Note that we count promotion |
duke@435 | 428 | // failure cleanup time as part of the collection (otherwise, we're |
duke@435 | 429 | // implicitly saying it's mutator time). |
duke@435 | 430 | size_policy->minor_collection_end(gc_cause); |
duke@435 | 431 | |
duke@435 | 432 | if (!promotion_failure_occurred) { |
duke@435 | 433 | // Swap the survivor spaces. |
jmasa@698 | 434 | |
jmasa@698 | 435 | |
jmasa@698 | 436 | young_gen->eden_space()->clear(SpaceDecorator::Mangle); |
jmasa@698 | 437 | young_gen->from_space()->clear(SpaceDecorator::Mangle); |
duke@435 | 438 | young_gen->swap_spaces(); |
duke@435 | 439 | |
duke@435 | 440 | size_t survived = young_gen->from_space()->used_in_bytes(); |
duke@435 | 441 | size_t promoted = old_gen->used_in_bytes() - old_gen_used_before; |
duke@435 | 442 | size_policy->update_averages(_survivor_overflow, survived, promoted); |
duke@435 | 443 | |
jmasa@1822 | 444 | // A successful scavenge should restart the GC time limit count which is |
jmasa@1822 | 445 | // for full GC's. |
jmasa@1822 | 446 | size_policy->reset_gc_overhead_limit_count(); |
duke@435 | 447 | if (UseAdaptiveSizePolicy) { |
duke@435 | 448 | // Calculate the new survivor size and tenuring threshold |
duke@435 | 449 | |
duke@435 | 450 | if (PrintAdaptiveSizePolicy) { |
duke@435 | 451 | gclog_or_tty->print("AdaptiveSizeStart: "); |
duke@435 | 452 | gclog_or_tty->stamp(); |
duke@435 | 453 | gclog_or_tty->print_cr(" collection: %d ", |
duke@435 | 454 | heap->total_collections()); |
duke@435 | 455 | |
duke@435 | 456 | if (Verbose) { |
duke@435 | 457 | gclog_or_tty->print("old_gen_capacity: %d young_gen_capacity: %d" |
duke@435 | 458 | " perm_gen_capacity: %d ", |
duke@435 | 459 | old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes(), |
duke@435 | 460 | perm_gen->capacity_in_bytes()); |
duke@435 | 461 | } |
duke@435 | 462 | } |
duke@435 | 463 | |
duke@435 | 464 | |
duke@435 | 465 | if (UsePerfData) { |
duke@435 | 466 | PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters(); |
duke@435 | 467 | counters->update_old_eden_size( |
duke@435 | 468 | size_policy->calculated_eden_size_in_bytes()); |
duke@435 | 469 | counters->update_old_promo_size( |
duke@435 | 470 | size_policy->calculated_promo_size_in_bytes()); |
duke@435 | 471 | counters->update_old_capacity(old_gen->capacity_in_bytes()); |
duke@435 | 472 | counters->update_young_capacity(young_gen->capacity_in_bytes()); |
duke@435 | 473 | counters->update_survived(survived); |
duke@435 | 474 | counters->update_promoted(promoted); |
duke@435 | 475 | counters->update_survivor_overflowed(_survivor_overflow); |
duke@435 | 476 | } |
duke@435 | 477 | |
duke@435 | 478 | size_t survivor_limit = |
duke@435 | 479 | size_policy->max_survivor_size(young_gen->max_size()); |
duke@435 | 480 | _tenuring_threshold = |
duke@435 | 481 | size_policy->compute_survivor_space_size_and_threshold( |
duke@435 | 482 | _survivor_overflow, |
duke@435 | 483 | _tenuring_threshold, |
duke@435 | 484 | survivor_limit); |
duke@435 | 485 | |
duke@435 | 486 | if (PrintTenuringDistribution) { |
duke@435 | 487 | gclog_or_tty->cr(); |
duke@435 | 488 | gclog_or_tty->print_cr("Desired survivor size %ld bytes, new threshold %d (max %d)", |
duke@435 | 489 | size_policy->calculated_survivor_size_in_bytes(), |
duke@435 | 490 | _tenuring_threshold, MaxTenuringThreshold); |
duke@435 | 491 | } |
duke@435 | 492 | |
duke@435 | 493 | if (UsePerfData) { |
duke@435 | 494 | PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters(); |
duke@435 | 495 | counters->update_tenuring_threshold(_tenuring_threshold); |
duke@435 | 496 | counters->update_survivor_size_counters(); |
duke@435 | 497 | } |
duke@435 | 498 | |
duke@435 | 499 | // Do call at minor collections? |
duke@435 | 500 | // Don't check if the size_policy is ready at this |
duke@435 | 501 | // level. Let the size_policy check that internally. |
duke@435 | 502 | if (UseAdaptiveSizePolicy && |
duke@435 | 503 | UseAdaptiveGenerationSizePolicyAtMinorCollection && |
duke@435 | 504 | ((gc_cause != GCCause::_java_lang_system_gc) || |
duke@435 | 505 | UseAdaptiveSizePolicyWithSystemGC)) { |
duke@435 | 506 | |
duke@435 | 507 | // Calculate optimial free space amounts |
duke@435 | 508 | assert(young_gen->max_size() > |
duke@435 | 509 | young_gen->from_space()->capacity_in_bytes() + |
duke@435 | 510 | young_gen->to_space()->capacity_in_bytes(), |
duke@435 | 511 | "Sizes of space in young gen are out-of-bounds"); |
duke@435 | 512 | size_t max_eden_size = young_gen->max_size() - |
duke@435 | 513 | young_gen->from_space()->capacity_in_bytes() - |
duke@435 | 514 | young_gen->to_space()->capacity_in_bytes(); |
duke@435 | 515 | size_policy->compute_generation_free_space(young_gen->used_in_bytes(), |
duke@435 | 516 | young_gen->eden_space()->used_in_bytes(), |
duke@435 | 517 | old_gen->used_in_bytes(), |
duke@435 | 518 | perm_gen->used_in_bytes(), |
duke@435 | 519 | young_gen->eden_space()->capacity_in_bytes(), |
duke@435 | 520 | old_gen->max_gen_size(), |
duke@435 | 521 | max_eden_size, |
duke@435 | 522 | false /* full gc*/, |
jmasa@1822 | 523 | gc_cause, |
jmasa@1822 | 524 | heap->collector_policy()); |
duke@435 | 525 | |
duke@435 | 526 | } |
duke@435 | 527 | // Resize the young generation at every collection |
duke@435 | 528 | // even if new sizes have not been calculated. This is |
duke@435 | 529 | // to allow resizes that may have been inhibited by the |
duke@435 | 530 | // relative location of the "to" and "from" spaces. |
duke@435 | 531 | |
duke@435 | 532 | // Resizing the old gen at minor collects can cause increases |
duke@435 | 533 | // that don't feed back to the generation sizing policy until |
duke@435 | 534 | // a major collection. Don't resize the old gen here. |
duke@435 | 535 | |
duke@435 | 536 | heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(), |
duke@435 | 537 | size_policy->calculated_survivor_size_in_bytes()); |
duke@435 | 538 | |
duke@435 | 539 | if (PrintAdaptiveSizePolicy) { |
duke@435 | 540 | gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ", |
duke@435 | 541 | heap->total_collections()); |
duke@435 | 542 | } |
duke@435 | 543 | } |
duke@435 | 544 | |
duke@435 | 545 | // Update the structure of the eden. With NUMA-eden CPU hotplugging or offlining can |
duke@435 | 546 | // cause the change of the heap layout. Make sure eden is reshaped if that's the case. |
duke@435 | 547 | // Also update() will case adaptive NUMA chunk resizing. |
duke@435 | 548 | assert(young_gen->eden_space()->is_empty(), "eden space should be empty now"); |
duke@435 | 549 | young_gen->eden_space()->update(); |
duke@435 | 550 | |
duke@435 | 551 | heap->gc_policy_counters()->update_counters(); |
duke@435 | 552 | |
duke@435 | 553 | heap->resize_all_tlabs(); |
duke@435 | 554 | |
duke@435 | 555 | assert(young_gen->to_space()->is_empty(), "to space should be empty now"); |
duke@435 | 556 | } |
duke@435 | 557 | |
duke@435 | 558 | COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); |
duke@435 | 559 | |
duke@435 | 560 | NOT_PRODUCT(reference_processor()->verify_no_references_recorded()); |
duke@435 | 561 | |
duke@435 | 562 | // Re-verify object start arrays |
duke@435 | 563 | if (VerifyObjectStartArray && |
duke@435 | 564 | VerifyAfterGC) { |
duke@435 | 565 | old_gen->verify_object_start_array(); |
duke@435 | 566 | perm_gen->verify_object_start_array(); |
duke@435 | 567 | } |
duke@435 | 568 | |
duke@435 | 569 | // Verify all old -> young cards are now precise |
duke@435 | 570 | if (VerifyRememberedSets) { |
duke@435 | 571 | // Precise verification will give false positives. Until this is fixed, |
duke@435 | 572 | // use imprecise verification. |
duke@435 | 573 | // CardTableExtension::verify_all_young_refs_precise(); |
duke@435 | 574 | CardTableExtension::verify_all_young_refs_imprecise(); |
duke@435 | 575 | } |
duke@435 | 576 | |
duke@435 | 577 | if (TraceGen0Time) accumulated_time()->stop(); |
duke@435 | 578 | |
duke@435 | 579 | if (PrintGC) { |
duke@435 | 580 | if (PrintGCDetails) { |
duke@435 | 581 | // Don't print a GC timestamp here. This is after the GC so |
duke@435 | 582 | // would be confusing. |
duke@435 | 583 | young_gen->print_used_change(young_gen_used_before); |
duke@435 | 584 | } |
duke@435 | 585 | heap->print_heap_change(prev_used); |
duke@435 | 586 | } |
duke@435 | 587 | |
duke@435 | 588 | // Track memory usage and detect low memory |
duke@435 | 589 | MemoryService::track_memory_usage(); |
duke@435 | 590 | heap->update_counters(); |
duke@435 | 591 | } |
duke@435 | 592 | |
duke@435 | 593 | if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) { |
duke@435 | 594 | HandleMark hm; // Discard invalid handles created during verification |
duke@435 | 595 | gclog_or_tty->print(" VerifyAfterGC:"); |
duke@435 | 596 | Universe::verify(false); |
duke@435 | 597 | } |
duke@435 | 598 | |
duke@435 | 599 | if (PrintHeapAtGC) { |
duke@435 | 600 | Universe::print_heap_after_gc(); |
duke@435 | 601 | } |
duke@435 | 602 | |
jmasa@698 | 603 | if (ZapUnusedHeapArea) { |
jmasa@698 | 604 | young_gen->eden_space()->check_mangled_unused_area_complete(); |
jmasa@698 | 605 | young_gen->from_space()->check_mangled_unused_area_complete(); |
jmasa@698 | 606 | young_gen->to_space()->check_mangled_unused_area_complete(); |
jmasa@698 | 607 | } |
jmasa@698 | 608 | |
duke@435 | 609 | scavenge_exit.update(); |
duke@435 | 610 | |
duke@435 | 611 | if (PrintGCTaskTimeStamps) { |
duke@435 | 612 | tty->print_cr("VM-Thread " INT64_FORMAT " " INT64_FORMAT " " INT64_FORMAT, |
duke@435 | 613 | scavenge_entry.ticks(), scavenge_midpoint.ticks(), |
duke@435 | 614 | scavenge_exit.ticks()); |
duke@435 | 615 | gc_task_manager()->print_task_time_stamps(); |
duke@435 | 616 | } |
duke@435 | 617 | |
jmasa@981 | 618 | #ifdef TRACESPINNING |
jmasa@981 | 619 | ParallelTaskTerminator::print_termination_counts(); |
jmasa@981 | 620 | #endif |
jmasa@981 | 621 | |
duke@435 | 622 | return !promotion_failure_occurred; |
duke@435 | 623 | } |
duke@435 | 624 | |
duke@435 | 625 | // This method iterates over all objects in the young generation, |
duke@435 | 626 | // unforwarding markOops. It then restores any preserved mark oops, |
duke@435 | 627 | // and clears the _preserved_mark_stack. |
duke@435 | 628 | void PSScavenge::clean_up_failed_promotion() { |
duke@435 | 629 | ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); |
duke@435 | 630 | assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); |
duke@435 | 631 | assert(promotion_failed(), "Sanity"); |
duke@435 | 632 | |
duke@435 | 633 | PSYoungGen* young_gen = heap->young_gen(); |
duke@435 | 634 | |
duke@435 | 635 | { |
duke@435 | 636 | ResourceMark rm; |
duke@435 | 637 | |
duke@435 | 638 | // Unforward all pointers in the young gen. |
duke@435 | 639 | PSPromotionFailedClosure unforward_closure; |
duke@435 | 640 | young_gen->object_iterate(&unforward_closure); |
duke@435 | 641 | |
duke@435 | 642 | if (PrintGC && Verbose) { |
duke@435 | 643 | gclog_or_tty->print_cr("Restoring %d marks", |
duke@435 | 644 | _preserved_oop_stack->length()); |
duke@435 | 645 | } |
duke@435 | 646 | |
duke@435 | 647 | // Restore any saved marks. |
duke@435 | 648 | for (int i=0; i < _preserved_oop_stack->length(); i++) { |
duke@435 | 649 | oop obj = _preserved_oop_stack->at(i); |
duke@435 | 650 | markOop mark = _preserved_mark_stack->at(i); |
duke@435 | 651 | obj->set_mark(mark); |
duke@435 | 652 | } |
duke@435 | 653 | |
duke@435 | 654 | // Deallocate the preserved mark and oop stacks. |
duke@435 | 655 | // The stacks were allocated as CHeap objects, so |
duke@435 | 656 | // we must call delete to prevent mem leaks. |
duke@435 | 657 | delete _preserved_mark_stack; |
duke@435 | 658 | _preserved_mark_stack = NULL; |
duke@435 | 659 | delete _preserved_oop_stack; |
duke@435 | 660 | _preserved_oop_stack = NULL; |
duke@435 | 661 | } |
duke@435 | 662 | |
duke@435 | 663 | // Reset the PromotionFailureALot counters. |
duke@435 | 664 | NOT_PRODUCT(Universe::heap()->reset_promotion_should_fail();) |
duke@435 | 665 | } |
duke@435 | 666 | |
duke@435 | 667 | // This method is called whenever an attempt to promote an object |
duke@435 | 668 | // fails. Some markOops will need preserving, some will not. Note |
duke@435 | 669 | // that the entire eden is traversed after a failed promotion, with |
duke@435 | 670 | // all forwarded headers replaced by the default markOop. This means |
duke@435 | 671 | // it is not neccessary to preserve most markOops. |
duke@435 | 672 | void PSScavenge::oop_promotion_failed(oop obj, markOop obj_mark) { |
duke@435 | 673 | if (_preserved_mark_stack == NULL) { |
duke@435 | 674 | ThreadCritical tc; // Lock and retest |
duke@435 | 675 | if (_preserved_mark_stack == NULL) { |
duke@435 | 676 | assert(_preserved_oop_stack == NULL, "Sanity"); |
duke@435 | 677 | _preserved_mark_stack = new (ResourceObj::C_HEAP) GrowableArray<markOop>(40, true); |
duke@435 | 678 | _preserved_oop_stack = new (ResourceObj::C_HEAP) GrowableArray<oop>(40, true); |
duke@435 | 679 | } |
duke@435 | 680 | } |
duke@435 | 681 | |
duke@435 | 682 | // Because we must hold the ThreadCritical lock before using |
duke@435 | 683 | // the stacks, we should be safe from observing partial allocations, |
duke@435 | 684 | // which are also guarded by the ThreadCritical lock. |
duke@435 | 685 | if (obj_mark->must_be_preserved_for_promotion_failure(obj)) { |
duke@435 | 686 | ThreadCritical tc; |
duke@435 | 687 | _preserved_oop_stack->push(obj); |
duke@435 | 688 | _preserved_mark_stack->push(obj_mark); |
duke@435 | 689 | } |
duke@435 | 690 | } |
duke@435 | 691 | |
duke@435 | 692 | bool PSScavenge::should_attempt_scavenge() { |
duke@435 | 693 | ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); |
duke@435 | 694 | assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); |
duke@435 | 695 | PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters(); |
duke@435 | 696 | |
duke@435 | 697 | if (UsePerfData) { |
duke@435 | 698 | counters->update_scavenge_skipped(not_skipped); |
duke@435 | 699 | } |
duke@435 | 700 | |
duke@435 | 701 | PSYoungGen* young_gen = heap->young_gen(); |
duke@435 | 702 | PSOldGen* old_gen = heap->old_gen(); |
duke@435 | 703 | |
duke@435 | 704 | if (!ScavengeWithObjectsInToSpace) { |
duke@435 | 705 | // Do not attempt to promote unless to_space is empty |
duke@435 | 706 | if (!young_gen->to_space()->is_empty()) { |
duke@435 | 707 | _consecutive_skipped_scavenges++; |
duke@435 | 708 | if (UsePerfData) { |
duke@435 | 709 | counters->update_scavenge_skipped(to_space_not_empty); |
duke@435 | 710 | } |
duke@435 | 711 | return false; |
duke@435 | 712 | } |
duke@435 | 713 | } |
duke@435 | 714 | |
duke@435 | 715 | // Test to see if the scavenge will likely fail. |
duke@435 | 716 | PSAdaptiveSizePolicy* policy = heap->size_policy(); |
duke@435 | 717 | |
duke@435 | 718 | // A similar test is done in the policy's should_full_GC(). If this is |
duke@435 | 719 | // changed, decide if that test should also be changed. |
duke@435 | 720 | size_t avg_promoted = (size_t) policy->padded_average_promoted_in_bytes(); |
duke@435 | 721 | size_t promotion_estimate = MIN2(avg_promoted, young_gen->used_in_bytes()); |
duke@435 | 722 | bool result = promotion_estimate < old_gen->free_in_bytes(); |
duke@435 | 723 | |
duke@435 | 724 | if (PrintGCDetails && Verbose) { |
duke@435 | 725 | gclog_or_tty->print(result ? " do scavenge: " : " skip scavenge: "); |
duke@435 | 726 | gclog_or_tty->print_cr(" average_promoted " SIZE_FORMAT |
duke@435 | 727 | " padded_average_promoted " SIZE_FORMAT |
duke@435 | 728 | " free in old gen " SIZE_FORMAT, |
duke@435 | 729 | (size_t) policy->average_promoted_in_bytes(), |
duke@435 | 730 | (size_t) policy->padded_average_promoted_in_bytes(), |
duke@435 | 731 | old_gen->free_in_bytes()); |
duke@435 | 732 | if (young_gen->used_in_bytes() < |
duke@435 | 733 | (size_t) policy->padded_average_promoted_in_bytes()) { |
duke@435 | 734 | gclog_or_tty->print_cr(" padded_promoted_average is greater" |
duke@435 | 735 | " than maximum promotion = " SIZE_FORMAT, young_gen->used_in_bytes()); |
duke@435 | 736 | } |
duke@435 | 737 | } |
duke@435 | 738 | |
duke@435 | 739 | if (result) { |
duke@435 | 740 | _consecutive_skipped_scavenges = 0; |
duke@435 | 741 | } else { |
duke@435 | 742 | _consecutive_skipped_scavenges++; |
duke@435 | 743 | if (UsePerfData) { |
duke@435 | 744 | counters->update_scavenge_skipped(promoted_too_large); |
duke@435 | 745 | } |
duke@435 | 746 | } |
duke@435 | 747 | return result; |
duke@435 | 748 | } |
duke@435 | 749 | |
duke@435 | 750 | // Used to add tasks |
duke@435 | 751 | GCTaskManager* const PSScavenge::gc_task_manager() { |
duke@435 | 752 | assert(ParallelScavengeHeap::gc_task_manager() != NULL, |
duke@435 | 753 | "shouldn't return NULL"); |
duke@435 | 754 | return ParallelScavengeHeap::gc_task_manager(); |
duke@435 | 755 | } |
duke@435 | 756 | |
duke@435 | 757 | void PSScavenge::initialize() { |
duke@435 | 758 | // Arguments must have been parsed |
duke@435 | 759 | |
duke@435 | 760 | if (AlwaysTenure) { |
duke@435 | 761 | _tenuring_threshold = 0; |
duke@435 | 762 | } else if (NeverTenure) { |
duke@435 | 763 | _tenuring_threshold = markOopDesc::max_age + 1; |
duke@435 | 764 | } else { |
duke@435 | 765 | // We want to smooth out our startup times for the AdaptiveSizePolicy |
duke@435 | 766 | _tenuring_threshold = (UseAdaptiveSizePolicy) ? InitialTenuringThreshold : |
duke@435 | 767 | MaxTenuringThreshold; |
duke@435 | 768 | } |
duke@435 | 769 | |
duke@435 | 770 | ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); |
duke@435 | 771 | assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); |
duke@435 | 772 | |
duke@435 | 773 | PSYoungGen* young_gen = heap->young_gen(); |
duke@435 | 774 | PSOldGen* old_gen = heap->old_gen(); |
duke@435 | 775 | PSPermGen* perm_gen = heap->perm_gen(); |
duke@435 | 776 | |
duke@435 | 777 | // Set boundary between young_gen and old_gen |
duke@435 | 778 | assert(perm_gen->reserved().end() <= old_gen->object_space()->bottom(), |
duke@435 | 779 | "perm above old"); |
duke@435 | 780 | assert(old_gen->reserved().end() <= young_gen->eden_space()->bottom(), |
duke@435 | 781 | "old above young"); |
duke@435 | 782 | _young_generation_boundary = young_gen->eden_space()->bottom(); |
duke@435 | 783 | |
duke@435 | 784 | // Initialize ref handling object for scavenging. |
duke@435 | 785 | MemRegion mr = young_gen->reserved(); |
duke@435 | 786 | _ref_processor = ReferenceProcessor::create_ref_processor( |
duke@435 | 787 | mr, // span |
duke@435 | 788 | true, // atomic_discovery |
duke@435 | 789 | true, // mt_discovery |
duke@435 | 790 | NULL, // is_alive_non_header |
duke@435 | 791 | ParallelGCThreads, |
duke@435 | 792 | ParallelRefProcEnabled); |
duke@435 | 793 | |
duke@435 | 794 | // Cache the cardtable |
duke@435 | 795 | BarrierSet* bs = Universe::heap()->barrier_set(); |
duke@435 | 796 | assert(bs->kind() == BarrierSet::CardTableModRef, "Wrong barrier set kind"); |
duke@435 | 797 | _card_table = (CardTableExtension*)bs; |
duke@435 | 798 | |
duke@435 | 799 | _counters = new CollectorCounters("PSScavenge", 0); |
duke@435 | 800 | } |