16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "code/codeCache.hpp"
27 #include "gc/parallel/adjoiningGenerations.hpp"
28 #include "gc/parallel/adjoiningVirtualSpaces.hpp"
29 #include "gc/parallel/cardTableExtension.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/psMarkSweep.hpp"
36 #include "gc/parallel/psParallelCompact.inline.hpp"
37 #include "gc/parallel/psPromotionManager.hpp"
38 #include "gc/parallel/psScavenge.hpp"
39 #include "gc/parallel/vmPSOperations.hpp"
40 #include "gc/shared/gcHeapSummary.hpp"
41 #include "gc/shared/gcLocker.inline.hpp"
42 #include "gc/shared/gcWhen.hpp"
43 #include "logging/log.hpp"
44 #include "oops/oop.inline.hpp"
45 #include "runtime/handles.inline.hpp"
46 #include "runtime/java.hpp"
47 #include "runtime/vmThread.hpp"
48 #include "services/memTracker.hpp"
49 #include "utilities/vmError.hpp"
50
51 PSYoungGen* ParallelScavengeHeap::_young_gen = NULL;
52 PSOldGen* ParallelScavengeHeap::_old_gen = NULL;
53 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
54 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
55 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
56
57 jint ParallelScavengeHeap::initialize() {
58 CollectedHeap::pre_initialize();
59
60 const size_t heap_size = _collector_policy->max_heap_byte_size();
61
62 ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->heap_alignment());
63
64 os::trace_page_sizes("Heap",
65 _collector_policy->min_heap_byte_size(),
66 heap_size,
67 generation_alignment(),
102 );
103
104 assert(!UseAdaptiveGCBoundary ||
105 (old_gen()->virtual_space()->high_boundary() ==
106 young_gen()->virtual_space()->low_boundary()),
107 "Boundaries must meet");
108 // initialize the policy counters - 2 collectors, 2 generations
109 _gc_policy_counters =
110 new PSGCAdaptivePolicyCounters("ParScav:MSC", 2, 2, _size_policy);
111
112 // Set up the GCTaskManager
113 _gc_task_manager = GCTaskManager::create(ParallelGCThreads);
114
115 if (UseParallelOldGC && !PSParallelCompact::initialize()) {
116 return JNI_ENOMEM;
117 }
118
119 return JNI_OK;
120 }
121
122 void ParallelScavengeHeap::post_initialize() {
123 // Need to init the tenuring threshold
124 PSScavenge::initialize();
125 if (UseParallelOldGC) {
126 PSParallelCompact::post_initialize();
127 } else {
128 PSMarkSweep::initialize();
129 }
130 PSPromotionManager::initialize();
131 }
132
133 void ParallelScavengeHeap::update_counters() {
134 young_gen()->update_counters();
135 old_gen()->update_counters();
136 MetaspaceCounters::update_performance_counters();
137 CompressedClassSpaceCounters::update_performance_counters();
138 }
139
140 size_t ParallelScavengeHeap::capacity() const {
141 size_t value = young_gen()->capacity_in_bytes() + old_gen()->capacity_in_bytes();
142 return value;
657 if (ZapUnusedHeapArea) {
658 young_gen()->eden_space()->mangle_unused_area();
659 young_gen()->to_space()->mangle_unused_area();
660 young_gen()->from_space()->mangle_unused_area();
661 old_gen()->object_space()->mangle_unused_area();
662 }
663 }
664 #endif
665
666 bool ParallelScavengeHeap::is_scavengable(oop obj) {
667 return is_in_young(obj);
668 }
669
670 void ParallelScavengeHeap::register_nmethod(nmethod* nm) {
671 CodeCache::register_scavenge_root_nmethod(nm);
672 }
673
674 void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
675 CodeCache::verify_scavenge_root_nmethod(nm);
676 }
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "code/codeCache.hpp"
27 #include "gc/parallel/adjoiningGenerations.hpp"
28 #include "gc/parallel/adjoiningVirtualSpaces.hpp"
29 #include "gc/parallel/cardTableExtension.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/psMarkSweep.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/vmPSOperations.hpp"
41 #include "gc/shared/gcHeapSummary.hpp"
42 #include "gc/shared/gcLocker.inline.hpp"
43 #include "gc/shared/gcWhen.hpp"
44 #include "logging/log.hpp"
45 #include "oops/oop.inline.hpp"
46 #include "runtime/handles.inline.hpp"
47 #include "runtime/java.hpp"
48 #include "runtime/vmThread.hpp"
49 #include "services/memoryManager.hpp"
50 #include "services/memTracker.hpp"
51 #include "utilities/vmError.hpp"
52
53 PSYoungGen* ParallelScavengeHeap::_young_gen = NULL;
54 PSOldGen* ParallelScavengeHeap::_old_gen = NULL;
55 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
56 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
57 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
58
59 jint ParallelScavengeHeap::initialize() {
60 CollectedHeap::pre_initialize();
61
62 const size_t heap_size = _collector_policy->max_heap_byte_size();
63
64 ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->heap_alignment());
65
66 os::trace_page_sizes("Heap",
67 _collector_policy->min_heap_byte_size(),
68 heap_size,
69 generation_alignment(),
104 );
105
106 assert(!UseAdaptiveGCBoundary ||
107 (old_gen()->virtual_space()->high_boundary() ==
108 young_gen()->virtual_space()->low_boundary()),
109 "Boundaries must meet");
110 // initialize the policy counters - 2 collectors, 2 generations
111 _gc_policy_counters =
112 new PSGCAdaptivePolicyCounters("ParScav:MSC", 2, 2, _size_policy);
113
114 // Set up the GCTaskManager
115 _gc_task_manager = GCTaskManager::create(ParallelGCThreads);
116
117 if (UseParallelOldGC && !PSParallelCompact::initialize()) {
118 return JNI_ENOMEM;
119 }
120
121 return JNI_OK;
122 }
123
124 void ParallelScavengeHeap::initialize_serviceability() {
125
126 _eden_pool = new EdenMutableSpacePool(_young_gen,
127 _young_gen->eden_space(),
128 "PS Eden Space",
129 false /* support_usage_threshold */);
130
131 _survivor_pool = new SurvivorMutableSpacePool(_young_gen,
132 "PS Survivor Space",
133 false /* support_usage_threshold */);
134
135 _old_pool = new PSGenerationPool(_old_gen,
136 "PS Old Gen",
137 true /* support_usage_threshold */);
138
139 _young_manager = new GCMemoryManager("PS Scavenge", "end of minor GC");
140 _old_manager = new GCMemoryManager("PS MarkSweep", "end of major GC");
141
142 _old_manager->add_pool(_eden_pool);
143 _old_manager->add_pool(_survivor_pool);
144 _old_manager->add_pool(_old_pool);
145
146 _young_manager->add_pool(_eden_pool);
147 _young_manager->add_pool(_survivor_pool);
148
149 }
150
151 void ParallelScavengeHeap::post_initialize() {
152 CollectedHeap::post_initialize();
153 // Need to init the tenuring threshold
154 PSScavenge::initialize();
155 if (UseParallelOldGC) {
156 PSParallelCompact::post_initialize();
157 } else {
158 PSMarkSweep::initialize();
159 }
160 PSPromotionManager::initialize();
161 }
162
163 void ParallelScavengeHeap::update_counters() {
164 young_gen()->update_counters();
165 old_gen()->update_counters();
166 MetaspaceCounters::update_performance_counters();
167 CompressedClassSpaceCounters::update_performance_counters();
168 }
169
170 size_t ParallelScavengeHeap::capacity() const {
171 size_t value = young_gen()->capacity_in_bytes() + old_gen()->capacity_in_bytes();
172 return value;
687 if (ZapUnusedHeapArea) {
688 young_gen()->eden_space()->mangle_unused_area();
689 young_gen()->to_space()->mangle_unused_area();
690 young_gen()->from_space()->mangle_unused_area();
691 old_gen()->object_space()->mangle_unused_area();
692 }
693 }
694 #endif
695
696 bool ParallelScavengeHeap::is_scavengable(oop obj) {
697 return is_in_young(obj);
698 }
699
700 void ParallelScavengeHeap::register_nmethod(nmethod* nm) {
701 CodeCache::register_scavenge_root_nmethod(nm);
702 }
703
704 void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
705 CodeCache::verify_scavenge_root_nmethod(nm);
706 }
707
708 GrowableArray<GCMemoryManager*> ParallelScavengeHeap::memory_managers() {
709 GrowableArray<GCMemoryManager*> memory_managers(2);
710 memory_managers.append(_young_manager);
711 memory_managers.append(_old_manager);
712 return memory_managers;
713 }
714
715 GrowableArray<MemoryPool*> ParallelScavengeHeap::memory_pools() {
716 GrowableArray<MemoryPool*> memory_pools(3);
717 memory_pools.append(_eden_pool);
718 memory_pools.append(_survivor_pool);
719 memory_pools.append(_old_pool);
720 return memory_pools;
721 }
722
|