82 void GcThreadCountClosure::do_thread(Thread* thread) {
83 _count++;
84 }
85
86 void MemoryService::set_universe_heap(CollectedHeap* heap) {
87 CollectedHeap::Name kind = heap->kind();
88 switch (kind) {
89 case CollectedHeap::GenCollectedHeap : {
90 add_gen_collected_heap_info(GenCollectedHeap::heap());
91 break;
92 }
93 #if INCLUDE_ALL_GCS
94 case CollectedHeap::ParallelScavengeHeap : {
95 add_parallel_scavenge_heap_info(ParallelScavengeHeap::heap());
96 break;
97 }
98 case CollectedHeap::G1CollectedHeap : {
99 add_g1_heap_info(G1CollectedHeap::heap());
100 break;
101 }
102 #endif // INCLUDE_ALL_GCS
103 default: {
104 guarantee(false, "Unrecognized kind of heap");
105 }
106 }
107
108 // set the GC thread count
109 GcThreadCountClosure gctcc;
110 heap->gc_threads_do(&gctcc);
111 int count = gctcc.count();
112 if (count > 0) {
113 _minor_gc_manager->set_num_gc_threads(count);
114 _major_gc_manager->set_num_gc_threads(count);
115 }
116
117 // All memory pools and memory managers are initialized.
118 //
119 _minor_gc_manager->initialize_gc_stat_info();
120 _major_gc_manager->initialize_gc_stat_info();
121 }
170 // Two managers to keep statistics about _minor_gc_manager and _major_gc_manager GC.
171 _minor_gc_manager = MemoryManager::get_psScavenge_memory_manager();
172 _major_gc_manager = MemoryManager::get_psMarkSweep_memory_manager();
173 _managers_list->append(_minor_gc_manager);
174 _managers_list->append(_major_gc_manager);
175
176 add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager);
177 add_psOld_memory_pool(heap->old_gen(), _major_gc_manager);
178 }
179
180 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) {
181 assert(UseG1GC, "sanity");
182
183 _minor_gc_manager = MemoryManager::get_g1YoungGen_memory_manager();
184 _major_gc_manager = MemoryManager::get_g1OldGen_memory_manager();
185 _managers_list->append(_minor_gc_manager);
186 _managers_list->append(_major_gc_manager);
187
188 add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager);
189 add_g1OldGen_memory_pool(g1h, _major_gc_manager);
190 }
191 #endif // INCLUDE_ALL_GCS
192
193 MemoryPool* MemoryService::add_gen(Generation* gen,
194 const char* name,
195 bool is_heap,
196 bool support_usage_threshold) {
197
198 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
199 GenerationPool* pool = new GenerationPool(gen, name, type, support_usage_threshold);
200 _pools_list->append(pool);
201 return (MemoryPool*) pool;
202 }
203
204 MemoryPool* MemoryService::add_space(ContiguousSpace* space,
205 const char* name,
206 bool is_heap,
207 size_t max_size,
208 bool support_usage_threshold) {
209 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
|
82 void GcThreadCountClosure::do_thread(Thread* thread) {
83 _count++;
84 }
85
86 void MemoryService::set_universe_heap(CollectedHeap* heap) {
87 CollectedHeap::Name kind = heap->kind();
88 switch (kind) {
89 case CollectedHeap::GenCollectedHeap : {
90 add_gen_collected_heap_info(GenCollectedHeap::heap());
91 break;
92 }
93 #if INCLUDE_ALL_GCS
94 case CollectedHeap::ParallelScavengeHeap : {
95 add_parallel_scavenge_heap_info(ParallelScavengeHeap::heap());
96 break;
97 }
98 case CollectedHeap::G1CollectedHeap : {
99 add_g1_heap_info(G1CollectedHeap::heap());
100 break;
101 }
102 case CollectedHeap::EpsilonCollectedHeap : {
103 add_epsilon_heap_info();
104 break;
105 }
106 #endif // INCLUDE_ALL_GCS
107 default: {
108 guarantee(false, "Unrecognized kind of heap");
109 }
110 }
111
112 // set the GC thread count
113 GcThreadCountClosure gctcc;
114 heap->gc_threads_do(&gctcc);
115 int count = gctcc.count();
116 if (count > 0) {
117 _minor_gc_manager->set_num_gc_threads(count);
118 _major_gc_manager->set_num_gc_threads(count);
119 }
120
121 // All memory pools and memory managers are initialized.
122 //
123 _minor_gc_manager->initialize_gc_stat_info();
124 _major_gc_manager->initialize_gc_stat_info();
125 }
174 // Two managers to keep statistics about _minor_gc_manager and _major_gc_manager GC.
175 _minor_gc_manager = MemoryManager::get_psScavenge_memory_manager();
176 _major_gc_manager = MemoryManager::get_psMarkSweep_memory_manager();
177 _managers_list->append(_minor_gc_manager);
178 _managers_list->append(_major_gc_manager);
179
180 add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager);
181 add_psOld_memory_pool(heap->old_gen(), _major_gc_manager);
182 }
183
184 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) {
185 assert(UseG1GC, "sanity");
186
187 _minor_gc_manager = MemoryManager::get_g1YoungGen_memory_manager();
188 _major_gc_manager = MemoryManager::get_g1OldGen_memory_manager();
189 _managers_list->append(_minor_gc_manager);
190 _managers_list->append(_major_gc_manager);
191
192 add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager);
193 add_g1OldGen_memory_pool(g1h, _major_gc_manager);
194 }
195
196 void MemoryService::add_epsilon_heap_info() {
197 assert(UseEpsilonGC, "sanity");
198
199 _minor_gc_manager = MemoryManager::get_epsilon_memory_manager();
200 _major_gc_manager = MemoryManager::get_epsilon_memory_manager();
201 _managers_list->append(_minor_gc_manager);
202 _managers_list->append(_major_gc_manager);
203 // TODO: fix these?
204 // add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager);
205 // add_g1OldGen_memory_pool(g1h, _major_gc_manager);
206 }
207 #endif // INCLUDE_ALL_GCS
208
209 MemoryPool* MemoryService::add_gen(Generation* gen,
210 const char* name,
211 bool is_heap,
212 bool support_usage_threshold) {
213
214 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
215 GenerationPool* pool = new GenerationPool(gen, name, type, support_usage_threshold);
216 _pools_list->append(pool);
217 return (MemoryPool*) pool;
218 }
219
220 MemoryPool* MemoryService::add_space(ContiguousSpace* space,
221 const char* name,
222 bool is_heap,
223 size_t max_size,
224 bool support_usage_threshold) {
225 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
|