37 #include "oops/oop.inline.hpp"
38 #include "runtime/globals.hpp"
39 #include "runtime/javaCalls.hpp"
40 #include "services/classLoadingService.hpp"
41 #include "services/lowMemoryDetector.hpp"
42 #include "services/management.hpp"
43 #include "services/memoryManager.hpp"
44 #include "services/memoryPool.hpp"
45 #include "services/memoryService.hpp"
46 #include "utilities/growableArray.hpp"
47 #include "utilities/macros.hpp"
48 #if INCLUDE_ALL_GCS
49 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
50 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
51 #include "gc_implementation/parNew/parNewGeneration.hpp"
52 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
53 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
54 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
55 #include "services/g1MemoryPool.hpp"
56 #include "services/psMemoryPool.hpp"
57 #endif // INCLUDE_ALL_GCS
58
59 GrowableArray<MemoryPool*>* MemoryService::_pools_list =
60 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true);
61 GrowableArray<MemoryManager*>* MemoryService::_managers_list =
62 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true);
63
64 GCMemoryManager* MemoryService::_minor_gc_manager = NULL;
65 GCMemoryManager* MemoryService::_major_gc_manager = NULL;
66 MemoryPool* MemoryService::_code_heap_pool = NULL;
67 MemoryPool* MemoryService::_metaspace_pool = NULL;
68 MemoryPool* MemoryService::_compressed_class_pool = NULL;
69
70 class GcThreadCountClosure: public ThreadClosure {
71 private:
72 int _count;
73 public:
74 GcThreadCountClosure() : _count(0) {};
75 void do_thread(Thread* thread);
76 int count() { return _count; }
79 void GcThreadCountClosure::do_thread(Thread* thread) {
80 _count++;
81 }
82
83 void MemoryService::set_universe_heap(CollectedHeap* heap) {
84 CollectedHeap::Name kind = heap->kind();
85 switch (kind) {
86 case CollectedHeap::GenCollectedHeap : {
87 add_gen_collected_heap_info(GenCollectedHeap::heap());
88 break;
89 }
90 #if INCLUDE_ALL_GCS
91 case CollectedHeap::ParallelScavengeHeap : {
92 add_parallel_scavenge_heap_info(ParallelScavengeHeap::heap());
93 break;
94 }
95 case CollectedHeap::G1CollectedHeap : {
96 add_g1_heap_info(G1CollectedHeap::heap());
97 break;
98 }
99 #endif // INCLUDE_ALL_GCS
100 default: {
101 guarantee(false, "Unrecognized kind of heap");
102 }
103 }
104
105 // set the GC thread count
106 GcThreadCountClosure gctcc;
107 heap->gc_threads_do(&gctcc);
108 int count = gctcc.count();
109 if (count > 0) {
110 _minor_gc_manager->set_num_gc_threads(count);
111 _major_gc_manager->set_num_gc_threads(count);
112 }
113
114 // All memory pools and memory managers are initialized.
115 //
116 _minor_gc_manager->initialize_gc_stat_info();
117 _major_gc_manager->initialize_gc_stat_info();
118 }
171 // Two managers to keep statistics about _minor_gc_manager and _major_gc_manager GC.
172 _minor_gc_manager = MemoryManager::get_psScavenge_memory_manager();
173 _major_gc_manager = MemoryManager::get_psMarkSweep_memory_manager();
174 _managers_list->append(_minor_gc_manager);
175 _managers_list->append(_major_gc_manager);
176
177 add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager);
178 add_psOld_memory_pool(heap->old_gen(), _major_gc_manager);
179 }
180
181 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) {
182 assert(UseG1GC, "sanity");
183
184 _minor_gc_manager = MemoryManager::get_g1YoungGen_memory_manager();
185 _major_gc_manager = MemoryManager::get_g1OldGen_memory_manager();
186 _managers_list->append(_minor_gc_manager);
187 _managers_list->append(_major_gc_manager);
188
189 add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager);
190 add_g1OldGen_memory_pool(g1h, _major_gc_manager);
191 }
192 #endif // INCLUDE_ALL_GCS
193
194 MemoryPool* MemoryService::add_gen(Generation* gen,
195 const char* name,
196 bool is_heap,
197 bool support_usage_threshold) {
198
199 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
200 GenerationPool* pool = new GenerationPool(gen, name, type, support_usage_threshold);
201 _pools_list->append(pool);
202 return (MemoryPool*) pool;
203 }
204
205 MemoryPool* MemoryService::add_space(ContiguousSpace* space,
206 const char* name,
207 bool is_heap,
208 size_t max_size,
209 bool support_usage_threshold) {
210 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
|
37 #include "oops/oop.inline.hpp"
38 #include "runtime/globals.hpp"
39 #include "runtime/javaCalls.hpp"
40 #include "services/classLoadingService.hpp"
41 #include "services/lowMemoryDetector.hpp"
42 #include "services/management.hpp"
43 #include "services/memoryManager.hpp"
44 #include "services/memoryPool.hpp"
45 #include "services/memoryService.hpp"
46 #include "utilities/growableArray.hpp"
47 #include "utilities/macros.hpp"
48 #if INCLUDE_ALL_GCS
49 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
50 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
51 #include "gc_implementation/parNew/parNewGeneration.hpp"
52 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
53 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
54 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
55 #include "services/g1MemoryPool.hpp"
56 #include "services/psMemoryPool.hpp"
57 #include "services/epsilonMemoryPool.hpp"
58 #endif // INCLUDE_ALL_GCS
59
60 GrowableArray<MemoryPool*>* MemoryService::_pools_list =
61 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true);
62 GrowableArray<MemoryManager*>* MemoryService::_managers_list =
63 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true);
64
65 GCMemoryManager* MemoryService::_minor_gc_manager = NULL;
66 GCMemoryManager* MemoryService::_major_gc_manager = NULL;
67 MemoryPool* MemoryService::_code_heap_pool = NULL;
68 MemoryPool* MemoryService::_metaspace_pool = NULL;
69 MemoryPool* MemoryService::_compressed_class_pool = NULL;
70
71 class GcThreadCountClosure: public ThreadClosure {
72 private:
73 int _count;
74 public:
75 GcThreadCountClosure() : _count(0) {};
76 void do_thread(Thread* thread);
77 int count() { return _count; }
80 void GcThreadCountClosure::do_thread(Thread* thread) {
81 _count++;
82 }
83
84 void MemoryService::set_universe_heap(CollectedHeap* heap) {
85 CollectedHeap::Name kind = heap->kind();
86 switch (kind) {
87 case CollectedHeap::GenCollectedHeap : {
88 add_gen_collected_heap_info(GenCollectedHeap::heap());
89 break;
90 }
91 #if INCLUDE_ALL_GCS
92 case CollectedHeap::ParallelScavengeHeap : {
93 add_parallel_scavenge_heap_info(ParallelScavengeHeap::heap());
94 break;
95 }
96 case CollectedHeap::G1CollectedHeap : {
97 add_g1_heap_info(G1CollectedHeap::heap());
98 break;
99 }
100 case CollectedHeap::EpsilonCollectedHeap : {
101 add_epsilon_heap_info(EpsilonCollectedHeap::heap());
102 break;
103 }
104 #endif // INCLUDE_ALL_GCS
105 default: {
106 guarantee(false, "Unrecognized kind of heap");
107 }
108 }
109
110 // set the GC thread count
111 GcThreadCountClosure gctcc;
112 heap->gc_threads_do(&gctcc);
113 int count = gctcc.count();
114 if (count > 0) {
115 _minor_gc_manager->set_num_gc_threads(count);
116 _major_gc_manager->set_num_gc_threads(count);
117 }
118
119 // All memory pools and memory managers are initialized.
120 //
121 _minor_gc_manager->initialize_gc_stat_info();
122 _major_gc_manager->initialize_gc_stat_info();
123 }
176 // Two managers to keep statistics about _minor_gc_manager and _major_gc_manager GC.
177 _minor_gc_manager = MemoryManager::get_psScavenge_memory_manager();
178 _major_gc_manager = MemoryManager::get_psMarkSweep_memory_manager();
179 _managers_list->append(_minor_gc_manager);
180 _managers_list->append(_major_gc_manager);
181
182 add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager);
183 add_psOld_memory_pool(heap->old_gen(), _major_gc_manager);
184 }
185
186 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) {
187 assert(UseG1GC, "sanity");
188
189 _minor_gc_manager = MemoryManager::get_g1YoungGen_memory_manager();
190 _major_gc_manager = MemoryManager::get_g1OldGen_memory_manager();
191 _managers_list->append(_minor_gc_manager);
192 _managers_list->append(_major_gc_manager);
193
194 add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager);
195 add_g1OldGen_memory_pool(g1h, _major_gc_manager);
196 }
197
198 void MemoryService::add_epsilon_heap_info(EpsilonCollectedHeap* eh) {
199 assert(UseEpsilonGC, "sanity");
200
201 _minor_gc_manager = MemoryManager::get_epsilon_memory_manager();
202 _major_gc_manager = MemoryManager::get_epsilon_memory_manager();
203 _managers_list->append(_minor_gc_manager);
204 _managers_list->append(_major_gc_manager);
205
206 EpsilonDummyMemoryPool* dummy = new EpsilonDummyMemoryPool();
207 _minor_gc_manager->add_pool(dummy);
208 _pools_list->append(dummy);
209
210 EpsilonMemoryPool* pool = new EpsilonMemoryPool(eh);
211 _major_gc_manager->add_pool(pool);
212 _pools_list->append(pool);
213 }
214 #endif // INCLUDE_ALL_GCS
215
216 MemoryPool* MemoryService::add_gen(Generation* gen,
217 const char* name,
218 bool is_heap,
219 bool support_usage_threshold) {
220
221 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
222 GenerationPool* pool = new GenerationPool(gen, name, type, support_usage_threshold);
223 _pools_list->append(pool);
224 return (MemoryPool*) pool;
225 }
226
227 MemoryPool* MemoryService::add_space(ContiguousSpace* space,
228 const char* name,
229 bool is_heap,
230 size_t max_size,
231 bool support_usage_threshold) {
232 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
|