src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp

rev 47972 : [mq]: open.patch

*** 31,40 ****
--- 31,41 ----
  #include "gc/parallel/generationSizer.hpp"
  #include "gc/parallel/objectStartArray.inline.hpp"
  #include "gc/parallel/parallelScavengeHeap.inline.hpp"
  #include "gc/parallel/psAdaptiveSizePolicy.hpp"
  #include "gc/parallel/psMarkSweep.hpp"
+ #include "gc/parallel/psMemoryPool.hpp"
  #include "gc/parallel/psParallelCompact.inline.hpp"
  #include "gc/parallel/psPromotionManager.hpp"
  #include "gc/parallel/psScavenge.hpp"
  #include "gc/parallel/vmPSOperations.hpp"
  #include "gc/shared/gcHeapSummary.hpp"
*** 43,52 ****
--- 44,54 ----
  #include "logging/log.hpp"
  #include "oops/oop.inline.hpp"
  #include "runtime/handles.inline.hpp"
  #include "runtime/java.hpp"
  #include "runtime/vmThread.hpp"
+ #include "services/memoryManager.hpp"
  #include "services/memTracker.hpp"
  #include "utilities/vmError.hpp"
  
  PSYoungGen*  ParallelScavengeHeap::_young_gen = NULL;
  PSOldGen*    ParallelScavengeHeap::_old_gen = NULL;
*** 114,123 ****
--- 116,149 ----
  
    if (UseParallelOldGC && !PSParallelCompact::initialize()) {
      return JNI_ENOMEM;
    }
  
+ 
+   _eden_pool = new EdenMutableSpacePool(_young_gen,
+                                         _young_gen->eden_space(),
+                                         "PS Eden Space",
+                                         false /* support_usage_threshold */);
+ 
+   _survivor_pool = new SurvivorMutableSpacePool(_young_gen,
+                                                 "PS Survivor Space",
+                                                 false /* support_usage_threshold */);
+ 
+   _old_pool = new PSGenerationPool(_old_gen,
+                                    "PS Old Gen",
+                                    true /* support_usage_threshold */);
+ 
+   _young_mgr = new GCMemoryManager("PS Scavenge", "end of minor GC");
+   _old_mgr = new GCMemoryManager("PS MarkSweep", "end of major GC");
+ 
+   _old_mgr->add_pool(_eden_pool);
+   _old_mgr->add_pool(_survivor_pool);
+   _old_mgr->add_pool(_old_pool);
+ 
+   _young_mgr->add_pool(_eden_pool);
+   _young_mgr->add_pool(_survivor_pool);
+ 
    return JNI_OK;
  }
  
  void ParallelScavengeHeap::post_initialize() {
    // Need to init the tenuring threshold
*** 672,676 ****
--- 698,718 ----
  }
  
  void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
    CodeCache::verify_scavenge_root_nmethod(nm);
  }
+ 
+ GrowableArray<GCMemoryManager*> ParallelScavengeHeap::memory_managers() {
+   GrowableArray<GCMemoryManager*> memory_managers(2);
+   memory_managers.append(_young_mgr);
+   memory_managers.append(_old_mgr);
+   return memory_managers;
+ }
+ 
+ GrowableArray<MemoryPool*> ParallelScavengeHeap::memory_pools() {
+   GrowableArray<MemoryPool*> memory_pools(3);
+   memory_pools.append(_eden_pool);
+   memory_pools.append(_survivor_pool);
+   memory_pools.append(_old_pool);
+   return memory_pools;
+ }
+