src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp
changeset 57773 5cbc3bd9fdfd
parent 57767 b3e44e1b135d
child 57903 5e2576c303a2
equal deleted inserted replaced
57772:2410b04f074f 57773:5cbc3bd9fdfd
    26 #include "code/codeCache.hpp"
    26 #include "code/codeCache.hpp"
    27 #include "gc/parallel/adjoiningGenerations.hpp"
    27 #include "gc/parallel/adjoiningGenerations.hpp"
    28 #include "gc/parallel/adjoiningGenerationsForHeteroHeap.hpp"
    28 #include "gc/parallel/adjoiningGenerationsForHeteroHeap.hpp"
    29 #include "gc/parallel/adjoiningVirtualSpaces.hpp"
    29 #include "gc/parallel/adjoiningVirtualSpaces.hpp"
    30 #include "gc/parallel/parallelArguments.hpp"
    30 #include "gc/parallel/parallelArguments.hpp"
    31 #include "gc/parallel/gcTaskManager.hpp"
       
    32 #include "gc/parallel/objectStartArray.inline.hpp"
    31 #include "gc/parallel/objectStartArray.inline.hpp"
    33 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
    32 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
    34 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
    33 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
    35 #include "gc/parallel/psMarkSweepProxy.hpp"
    34 #include "gc/parallel/psMarkSweepProxy.hpp"
    36 #include "gc/parallel/psMemoryPool.hpp"
    35 #include "gc/parallel/psMemoryPool.hpp"
    57 
    56 
    58 PSYoungGen*  ParallelScavengeHeap::_young_gen = NULL;
    57 PSYoungGen*  ParallelScavengeHeap::_young_gen = NULL;
    59 PSOldGen*    ParallelScavengeHeap::_old_gen = NULL;
    58 PSOldGen*    ParallelScavengeHeap::_old_gen = NULL;
    60 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
    59 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
    61 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
    60 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
    62 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
       
    63 
    61 
    64 jint ParallelScavengeHeap::initialize() {
    62 jint ParallelScavengeHeap::initialize() {
    65   const size_t reserved_heap_size = ParallelArguments::heap_reserved_size_bytes();
    63   const size_t reserved_heap_size = ParallelArguments::heap_reserved_size_bytes();
    66 
    64 
    67   ReservedSpace heap_rs = Universe::reserve_heap(reserved_heap_size, HeapAlignment);
    65   ReservedSpace heap_rs = Universe::reserve_heap(reserved_heap_size, HeapAlignment);
   113      young_gen()->virtual_space()->low_boundary()),
   111      young_gen()->virtual_space()->low_boundary()),
   114     "Boundaries must meet");
   112     "Boundaries must meet");
   115   // initialize the policy counters - 2 collectors, 2 generations
   113   // initialize the policy counters - 2 collectors, 2 generations
   116   _gc_policy_counters =
   114   _gc_policy_counters =
   117     new PSGCAdaptivePolicyCounters("ParScav:MSC", 2, 2, _size_policy);
   115     new PSGCAdaptivePolicyCounters("ParScav:MSC", 2, 2, _size_policy);
   118 
       
   119   // Set up the GCTaskManager
       
   120   _gc_task_manager = GCTaskManager::create(ParallelGCThreads);
       
   121 
   116 
   122   if (UseParallelOldGC && !PSParallelCompact::initialize()) {
   117   if (UseParallelOldGC && !PSParallelCompact::initialize()) {
   123     return JNI_ENOMEM;
   118     return JNI_ENOMEM;
   124   }
   119   }
   125 
   120 
   603     PSParallelCompact::print_on_error(st);
   598     PSParallelCompact::print_on_error(st);
   604   }
   599   }
   605 }
   600 }
   606 
   601 
   607 void ParallelScavengeHeap::gc_threads_do(ThreadClosure* tc) const {
   602 void ParallelScavengeHeap::gc_threads_do(ThreadClosure* tc) const {
   608   PSScavenge::gc_task_manager()->threads_do(tc);
   603   ParallelScavengeHeap::heap()->workers().threads_do(tc);
   609 }
   604 }
   610 
   605 
   611 void ParallelScavengeHeap::print_gc_threads_on(outputStream* st) const {
   606 void ParallelScavengeHeap::print_gc_threads_on(outputStream* st) const {
   612   PSScavenge::gc_task_manager()->print_threads_on(st);
   607   ParallelScavengeHeap::heap()->workers().print_worker_threads_on(st);
   613 }
   608 }
   614 
   609 
   615 void ParallelScavengeHeap::print_tracing_info() const {
   610 void ParallelScavengeHeap::print_tracing_info() const {
   616   AdaptiveSizePolicyOutput::print();
   611   AdaptiveSizePolicyOutput::print();
   617   log_debug(gc, heap, exit)("Accumulated young generation GC time %3.7f secs", PSScavenge::accumulated_time()->seconds());
   612   log_debug(gc, heap, exit)("Accumulated young generation GC time %3.7f secs", PSScavenge::accumulated_time()->seconds());