24
25 #include "precompiled.hpp"
26 #include "code/codeCache.hpp"
27 #include "gc/parallel/adjoiningGenerations.hpp"
28 #include "gc/parallel/adjoiningGenerationsForHeteroHeap.hpp"
29 #include "gc/parallel/adjoiningVirtualSpaces.hpp"
30 #include "gc/parallel/gcTaskManager.hpp"
31 #include "gc/parallel/generationSizer.hpp"
32 #include "gc/parallel/objectStartArray.inline.hpp"
33 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
34 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
35 #include "gc/parallel/psMarkSweepProxy.hpp"
36 #include "gc/parallel/psMemoryPool.hpp"
37 #include "gc/parallel/psParallelCompact.inline.hpp"
38 #include "gc/parallel/psPromotionManager.hpp"
39 #include "gc/parallel/psScavenge.hpp"
40 #include "gc/parallel/psVMOperations.hpp"
41 #include "gc/shared/gcHeapSummary.hpp"
42 #include "gc/shared/gcLocker.hpp"
43 #include "gc/shared/gcWhen.hpp"
44 #include "logging/log.hpp"
45 #include "memory/metaspaceCounters.hpp"
46 #include "oops/oop.inline.hpp"
47 #include "runtime/handles.inline.hpp"
48 #include "runtime/java.hpp"
49 #include "runtime/vmThread.hpp"
50 #include "services/memoryManager.hpp"
51 #include "services/memTracker.hpp"
52 #include "utilities/macros.hpp"
53 #include "utilities/vmError.hpp"
54
55 PSYoungGen* ParallelScavengeHeap::_young_gen = NULL;
56 PSOldGen* ParallelScavengeHeap::_old_gen = NULL;
57 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
58 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
59 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
60
61 jint ParallelScavengeHeap::initialize() {
62 size_t heap_size = _collector_policy->heap_reserved_size_bytes();
63
133 _survivor_pool = new SurvivorMutableSpacePool(_young_gen,
134 "PS Survivor Space",
135 false /* support_usage_threshold */);
136
137 _old_pool = new PSGenerationPool(_old_gen,
138 "PS Old Gen",
139 true /* support_usage_threshold */);
140
141 _young_manager = new GCMemoryManager("PS Scavenge", "end of minor GC");
142 _old_manager = new GCMemoryManager("PS MarkSweep", "end of major GC");
143
144 _old_manager->add_pool(_eden_pool);
145 _old_manager->add_pool(_survivor_pool);
146 _old_manager->add_pool(_old_pool);
147
148 _young_manager->add_pool(_eden_pool);
149 _young_manager->add_pool(_survivor_pool);
150
151 }
152
153 void ParallelScavengeHeap::post_initialize() {
154 CollectedHeap::post_initialize();
155 // Need to init the tenuring threshold
156 PSScavenge::initialize();
157 if (UseParallelOldGC) {
158 PSParallelCompact::post_initialize();
159 } else {
160 PSMarkSweepProxy::initialize();
161 }
162 PSPromotionManager::initialize();
163 }
164
165 void ParallelScavengeHeap::update_counters() {
166 young_gen()->update_counters();
167 old_gen()->update_counters();
168 MetaspaceCounters::update_performance_counters();
169 CompressedClassSpaceCounters::update_performance_counters();
170 }
171
172 size_t ParallelScavengeHeap::capacity() const {
173 size_t value = young_gen()->capacity_in_bytes() + old_gen()->capacity_in_bytes();
174 return value;
175 }
176
177 size_t ParallelScavengeHeap::used() const {
178 size_t value = young_gen()->used_in_bytes() + old_gen()->used_in_bytes();
179 return value;
180 }
181
182 bool ParallelScavengeHeap::is_maximal_no_gc() const {
680 }
681
682 #ifndef PRODUCT
683 void ParallelScavengeHeap::record_gen_tops_before_GC() {
684 if (ZapUnusedHeapArea) {
685 young_gen()->record_spaces_top();
686 old_gen()->record_spaces_top();
687 }
688 }
689
690 void ParallelScavengeHeap::gen_mangle_unused_area() {
691 if (ZapUnusedHeapArea) {
692 young_gen()->eden_space()->mangle_unused_area();
693 young_gen()->to_space()->mangle_unused_area();
694 young_gen()->from_space()->mangle_unused_area();
695 old_gen()->object_space()->mangle_unused_area();
696 }
697 }
698 #endif
699
700 bool ParallelScavengeHeap::is_scavengable(oop obj) {
701 return is_in_young(obj);
702 }
703
704 void ParallelScavengeHeap::register_nmethod(nmethod* nm) {
705 CodeCache::register_scavenge_root_nmethod(nm);
706 }
707
708 void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
709 CodeCache::verify_scavenge_root_nmethod(nm);
710 }
711
712 GrowableArray<GCMemoryManager*> ParallelScavengeHeap::memory_managers() {
713 GrowableArray<GCMemoryManager*> memory_managers(2);
714 memory_managers.append(_young_manager);
715 memory_managers.append(_old_manager);
716 return memory_managers;
717 }
718
719 GrowableArray<MemoryPool*> ParallelScavengeHeap::memory_pools() {
720 GrowableArray<MemoryPool*> memory_pools(3);
721 memory_pools.append(_eden_pool);
722 memory_pools.append(_survivor_pool);
723 memory_pools.append(_old_pool);
724 return memory_pools;
725 }
|
24
25 #include "precompiled.hpp"
26 #include "code/codeCache.hpp"
27 #include "gc/parallel/adjoiningGenerations.hpp"
28 #include "gc/parallel/adjoiningGenerationsForHeteroHeap.hpp"
29 #include "gc/parallel/adjoiningVirtualSpaces.hpp"
30 #include "gc/parallel/gcTaskManager.hpp"
31 #include "gc/parallel/generationSizer.hpp"
32 #include "gc/parallel/objectStartArray.inline.hpp"
33 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
34 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
35 #include "gc/parallel/psMarkSweepProxy.hpp"
36 #include "gc/parallel/psMemoryPool.hpp"
37 #include "gc/parallel/psParallelCompact.inline.hpp"
38 #include "gc/parallel/psPromotionManager.hpp"
39 #include "gc/parallel/psScavenge.hpp"
40 #include "gc/parallel/psVMOperations.hpp"
41 #include "gc/shared/gcHeapSummary.hpp"
42 #include "gc/shared/gcLocker.hpp"
43 #include "gc/shared/gcWhen.hpp"
44 #include "gc/shared/scavengableNMethods.hpp"
45 #include "logging/log.hpp"
46 #include "memory/metaspaceCounters.hpp"
47 #include "oops/oop.inline.hpp"
48 #include "runtime/handles.inline.hpp"
49 #include "runtime/java.hpp"
50 #include "runtime/vmThread.hpp"
51 #include "services/memoryManager.hpp"
52 #include "services/memTracker.hpp"
53 #include "utilities/macros.hpp"
54 #include "utilities/vmError.hpp"
55
56 PSYoungGen* ParallelScavengeHeap::_young_gen = NULL;
57 PSOldGen* ParallelScavengeHeap::_old_gen = NULL;
58 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
59 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
60 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
61
62 jint ParallelScavengeHeap::initialize() {
63 size_t heap_size = _collector_policy->heap_reserved_size_bytes();
64
134 _survivor_pool = new SurvivorMutableSpacePool(_young_gen,
135 "PS Survivor Space",
136 false /* support_usage_threshold */);
137
138 _old_pool = new PSGenerationPool(_old_gen,
139 "PS Old Gen",
140 true /* support_usage_threshold */);
141
142 _young_manager = new GCMemoryManager("PS Scavenge", "end of minor GC");
143 _old_manager = new GCMemoryManager("PS MarkSweep", "end of major GC");
144
145 _old_manager->add_pool(_eden_pool);
146 _old_manager->add_pool(_survivor_pool);
147 _old_manager->add_pool(_old_pool);
148
149 _young_manager->add_pool(_eden_pool);
150 _young_manager->add_pool(_survivor_pool);
151
152 }
153
154 namespace {
155 class PSIsScavengable : public BoolObjectClosure {
156 bool do_object_b(oop obj) {
157 return ParallelScavengeHeap::heap()->is_in_young(obj);
158 }
159 };
160
161 PSIsScavengable _is_scavengable;
162 }
163
164
165 void ParallelScavengeHeap::post_initialize() {
166 CollectedHeap::post_initialize();
167 // Need to init the tenuring threshold
168 PSScavenge::initialize();
169 if (UseParallelOldGC) {
170 PSParallelCompact::post_initialize();
171 } else {
172 PSMarkSweepProxy::initialize();
173 }
174 PSPromotionManager::initialize();
175
176 ScavengableNMethods::initialize(&_is_scavengable);
177 }
178
179 void ParallelScavengeHeap::update_counters() {
180 young_gen()->update_counters();
181 old_gen()->update_counters();
182 MetaspaceCounters::update_performance_counters();
183 CompressedClassSpaceCounters::update_performance_counters();
184 }
185
186 size_t ParallelScavengeHeap::capacity() const {
187 size_t value = young_gen()->capacity_in_bytes() + old_gen()->capacity_in_bytes();
188 return value;
189 }
190
191 size_t ParallelScavengeHeap::used() const {
192 size_t value = young_gen()->used_in_bytes() + old_gen()->used_in_bytes();
193 return value;
194 }
195
196 bool ParallelScavengeHeap::is_maximal_no_gc() const {
694 }
695
696 #ifndef PRODUCT
697 void ParallelScavengeHeap::record_gen_tops_before_GC() {
698 if (ZapUnusedHeapArea) {
699 young_gen()->record_spaces_top();
700 old_gen()->record_spaces_top();
701 }
702 }
703
704 void ParallelScavengeHeap::gen_mangle_unused_area() {
705 if (ZapUnusedHeapArea) {
706 young_gen()->eden_space()->mangle_unused_area();
707 young_gen()->to_space()->mangle_unused_area();
708 young_gen()->from_space()->mangle_unused_area();
709 old_gen()->object_space()->mangle_unused_area();
710 }
711 }
712 #endif
713
714 void ParallelScavengeHeap::register_nmethod(nmethod* nm) {
715 ScavengableNMethods::register_nmethod(nm);
716 }
717
718 void ParallelScavengeHeap::unregister_nmethod(nmethod* nm) {
719 ScavengableNMethods::unregister_nmethod(nm);
720 }
721
722 void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
723 ScavengableNMethods::verify_nmethod(nm);
724 }
725
726 void ParallelScavengeHeap::flush_nmethod(nmethod* nm) {
727 ScavengableNMethods::flush_nmethod(nm);
728 }
729
730 void ParallelScavengeHeap::prune_nmethods() {
731 ScavengableNMethods::prune_nmethods();
732 }
733
734 GrowableArray<GCMemoryManager*> ParallelScavengeHeap::memory_managers() {
735 GrowableArray<GCMemoryManager*> memory_managers(2);
736 memory_managers.append(_young_manager);
737 memory_managers.append(_old_manager);
738 return memory_managers;
739 }
740
741 GrowableArray<MemoryPool*> ParallelScavengeHeap::memory_pools() {
742 GrowableArray<MemoryPool*> memory_pools(3);
743 memory_pools.append(_eden_pool);
744 memory_pools.append(_survivor_pool);
745 memory_pools.append(_old_pool);
746 return memory_pools;
747 }
|