< prev index next >

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

Print this page
rev 48000 : [mq]: open.patch
rev 48001 : [mq]: 8191564-new.patch


 115   _gc_task_manager = GCTaskManager::create(ParallelGCThreads);
 116 
 117   if (UseParallelOldGC && !PSParallelCompact::initialize()) {
 118     return JNI_ENOMEM;
 119   }
 120 
 121 
 122   _eden_pool = new EdenMutableSpacePool(_young_gen,
 123                                         _young_gen->eden_space(),
 124                                         "PS Eden Space",
 125                                         false /* support_usage_threshold */);
 126 
 127   _survivor_pool = new SurvivorMutableSpacePool(_young_gen,
 128                                                 "PS Survivor Space",
 129                                                 false /* support_usage_threshold */);
 130 
 131   _old_pool = new PSGenerationPool(_old_gen,
 132                                    "PS Old Gen",
 133                                    true /* support_usage_threshold */);
 134 
 135   _young_mgr = new GCMemoryManager("PS Scavenge", "end of minor GC");
 136   _old_mgr = new GCMemoryManager("PS MarkSweep", "end of major GC");
 137 
 138   _old_mgr->add_pool(_eden_pool);
 139   _old_mgr->add_pool(_survivor_pool);
 140   _old_mgr->add_pool(_old_pool);
 141 
 142   _young_mgr->add_pool(_eden_pool);
 143   _young_mgr->add_pool(_survivor_pool);
 144 
 145   return JNI_OK;
 146 }
 147 
 148 void ParallelScavengeHeap::post_initialize() {
 149   // Need to init the tenuring threshold
 150   PSScavenge::initialize();
 151   if (UseParallelOldGC) {
 152     PSParallelCompact::post_initialize();
 153   } else {
 154     PSMarkSweep::initialize();
 155   }
 156   PSPromotionManager::initialize();
 157 }
 158 
 159 void ParallelScavengeHeap::update_counters() {
 160   young_gen()->update_counters();
 161   old_gen()->update_counters();
 162   MetaspaceCounters::update_performance_counters();
 163   CompressedClassSpaceCounters::update_performance_counters();


 686     young_gen()->from_space()->mangle_unused_area();
 687     old_gen()->object_space()->mangle_unused_area();
 688   }
 689 }
 690 #endif
 691 
 692 bool ParallelScavengeHeap::is_scavengable(oop obj) {
 693   return is_in_young(obj);
 694 }
 695 
 696 void ParallelScavengeHeap::register_nmethod(nmethod* nm) {
 697   CodeCache::register_scavenge_root_nmethod(nm);
 698 }
 699 
 700 void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
 701   CodeCache::verify_scavenge_root_nmethod(nm);
 702 }
 703 
 704 GrowableArray<GCMemoryManager*> ParallelScavengeHeap::memory_managers() {
 705   GrowableArray<GCMemoryManager*> memory_managers(2);
 706   memory_managers.append(_young_mgr);
 707   memory_managers.append(_old_mgr);
 708   return memory_managers;
 709 }
 710 
 711 GrowableArray<MemoryPool*> ParallelScavengeHeap::memory_pools() {
 712   GrowableArray<MemoryPool*> memory_pools(3);
 713   memory_pools.append(_eden_pool);
 714   memory_pools.append(_survivor_pool);
 715   memory_pools.append(_old_pool);
 716   return memory_pools;
 717 }
 718 


 115   _gc_task_manager = GCTaskManager::create(ParallelGCThreads);
 116 
 117   if (UseParallelOldGC && !PSParallelCompact::initialize()) {
 118     return JNI_ENOMEM;
 119   }
 120 
 121 
 122   _eden_pool = new EdenMutableSpacePool(_young_gen,
 123                                         _young_gen->eden_space(),
 124                                         "PS Eden Space",
 125                                         false /* support_usage_threshold */);
 126 
 127   _survivor_pool = new SurvivorMutableSpacePool(_young_gen,
 128                                                 "PS Survivor Space",
 129                                                 false /* support_usage_threshold */);
 130 
 131   _old_pool = new PSGenerationPool(_old_gen,
 132                                    "PS Old Gen",
 133                                    true /* support_usage_threshold */);
 134 
 135   _young_manager = new GCMemoryManager("PS Scavenge", "end of minor GC");
 136   _old_manager = new GCMemoryManager("PS MarkSweep", "end of major GC");
 137 
 138   _old_manager->add_pool(_eden_pool);
 139   _old_manager->add_pool(_survivor_pool);
 140   _old_manager->add_pool(_old_pool);
 141 
 142   _young_manager->add_pool(_eden_pool);
 143   _young_manager->add_pool(_survivor_pool);
 144 
 145   return JNI_OK;
 146 }
 147 
 148 void ParallelScavengeHeap::post_initialize() {
 149   // Need to init the tenuring threshold
 150   PSScavenge::initialize();
 151   if (UseParallelOldGC) {
 152     PSParallelCompact::post_initialize();
 153   } else {
 154     PSMarkSweep::initialize();
 155   }
 156   PSPromotionManager::initialize();
 157 }
 158 
 159 void ParallelScavengeHeap::update_counters() {
 160   young_gen()->update_counters();
 161   old_gen()->update_counters();
 162   MetaspaceCounters::update_performance_counters();
 163   CompressedClassSpaceCounters::update_performance_counters();


 686     young_gen()->from_space()->mangle_unused_area();
 687     old_gen()->object_space()->mangle_unused_area();
 688   }
 689 }
 690 #endif
 691 
 692 bool ParallelScavengeHeap::is_scavengable(oop obj) {
 693   return is_in_young(obj);
 694 }
 695 
 696 void ParallelScavengeHeap::register_nmethod(nmethod* nm) {
 697   CodeCache::register_scavenge_root_nmethod(nm);
 698 }
 699 
 700 void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
 701   CodeCache::verify_scavenge_root_nmethod(nm);
 702 }
 703 
 704 GrowableArray<GCMemoryManager*> ParallelScavengeHeap::memory_managers() {
 705   GrowableArray<GCMemoryManager*> memory_managers(2);
 706   memory_managers.append(_young_manager);
 707   memory_managers.append(_old_manager);
 708   return memory_managers;
 709 }
 710 
 711 GrowableArray<MemoryPool*> ParallelScavengeHeap::memory_pools() {
 712   GrowableArray<MemoryPool*> memory_pools(3);
 713   memory_pools.append(_eden_pool);
 714   memory_pools.append(_survivor_pool);
 715   memory_pools.append(_old_pool);
 716   return memory_pools;
 717 }
 718 
< prev index next >