29 #include "gc/shared/generation.hpp"
30 #include "memory/allocation.hpp"
31 #include "runtime/handles.hpp"
32 #include "services/memoryUsage.hpp"
33
34 // Forward declaration
35 class MemoryPool;
36 class MemoryManager;
37 class GCMemoryManager;
38 class CollectedHeap;
39 class Generation;
40 class DefNewGeneration;
41 class PSYoungGen;
42 class PSOldGen;
43 class CodeHeap;
44 class ContiguousSpace;
45 class CompactibleFreeListSpace;
46 class GenCollectedHeap;
47 class ParallelScavengeHeap;
48 class G1CollectedHeap;
49
50 // VM Monitoring and Management Support
51
52 class MemoryService : public AllStatic {
53 private:
54 enum {
55 init_pools_list_size = 10,
56 init_managers_list_size = 5,
57 init_code_heap_pools_size = 9
58 };
59
60 static GrowableArray<MemoryPool*>* _pools_list;
61 static GrowableArray<MemoryManager*>* _managers_list;
62
63 // memory managers for minor and major GC statistics
64 static GCMemoryManager* _major_gc_manager;
65 static GCMemoryManager* _minor_gc_manager;
66
67 // memory manager and code heap pools for the CodeCache
68 static MemoryManager* _code_cache_manager;
75 MemoryManager* major_mgr,
76 MemoryManager* minor_mgr);
77 static void add_generation_memory_pool(Generation* gen,
78 MemoryManager* major_mgr) {
79 add_generation_memory_pool(gen, major_mgr, NULL);
80 }
81
82
83 static void add_psYoung_memory_pool(PSYoungGen* young_gen,
84 MemoryManager* major_mgr,
85 MemoryManager* minor_mgr);
86 static void add_psOld_memory_pool(PSOldGen* old_gen,
87 MemoryManager* mgr);
88
89 static void add_g1YoungGen_memory_pool(G1CollectedHeap* g1h,
90 MemoryManager* major_mgr,
91 MemoryManager* minor_mgr);
92 static void add_g1OldGen_memory_pool(G1CollectedHeap* g1h,
93 MemoryManager* mgr);
94
95 static MemoryPool* add_space(ContiguousSpace* space,
96 const char* name,
97 bool is_heap,
98 size_t max_size,
99 bool support_usage_threshold);
100 static MemoryPool* add_survivor_spaces(DefNewGeneration* young_gen,
101 const char* name,
102 bool is_heap,
103 size_t max_size,
104 bool support_usage_threshold);
105 static MemoryPool* add_gen(Generation* gen,
106 const char* name,
107 bool is_heap,
108 bool support_usage_threshold);
109 static MemoryPool* add_cms_space(CompactibleFreeListSpace* space,
110 const char* name,
111 bool is_heap,
112 size_t max_size,
113 bool support_usage_threshold);
114
115 static void add_gen_collected_heap_info(GenCollectedHeap* heap);
116 static void add_parallel_scavenge_heap_info(ParallelScavengeHeap* heap);
117 static void add_g1_heap_info(G1CollectedHeap* g1h);
118
119 public:
120 static void set_universe_heap(CollectedHeap* heap);
121 static void add_code_heap_memory_pool(CodeHeap* heap, const char* name);
122 static void add_metaspace_memory_pools();
123
124 static MemoryPool* get_memory_pool(instanceHandle pool);
125 static MemoryManager* get_memory_manager(instanceHandle mgr);
126
127 static const int num_memory_pools() {
128 return _pools_list->length();
129 }
130 static const int num_memory_managers() {
131 return _managers_list->length();
132 }
133
134 static MemoryPool* get_memory_pool(int index) {
135 return _pools_list->at(index);
136 }
137
|
29 #include "gc/shared/generation.hpp"
30 #include "memory/allocation.hpp"
31 #include "runtime/handles.hpp"
32 #include "services/memoryUsage.hpp"
33
34 // Forward declaration
35 class MemoryPool;
36 class MemoryManager;
37 class GCMemoryManager;
38 class CollectedHeap;
39 class Generation;
40 class DefNewGeneration;
41 class PSYoungGen;
42 class PSOldGen;
43 class CodeHeap;
44 class ContiguousSpace;
45 class CompactibleFreeListSpace;
46 class GenCollectedHeap;
47 class ParallelScavengeHeap;
48 class G1CollectedHeap;
49 class ShenandoahHeap;
50
51 // VM Monitoring and Management Support
52
53 class MemoryService : public AllStatic {
54 private:
55 enum {
56 init_pools_list_size = 10,
57 init_managers_list_size = 5,
58 init_code_heap_pools_size = 9
59 };
60
61 static GrowableArray<MemoryPool*>* _pools_list;
62 static GrowableArray<MemoryManager*>* _managers_list;
63
64 // memory managers for minor and major GC statistics
65 static GCMemoryManager* _major_gc_manager;
66 static GCMemoryManager* _minor_gc_manager;
67
68 // memory manager and code heap pools for the CodeCache
69 static MemoryManager* _code_cache_manager;
76 MemoryManager* major_mgr,
77 MemoryManager* minor_mgr);
78 static void add_generation_memory_pool(Generation* gen,
79 MemoryManager* major_mgr) {
80 add_generation_memory_pool(gen, major_mgr, NULL);
81 }
82
83
84 static void add_psYoung_memory_pool(PSYoungGen* young_gen,
85 MemoryManager* major_mgr,
86 MemoryManager* minor_mgr);
87 static void add_psOld_memory_pool(PSOldGen* old_gen,
88 MemoryManager* mgr);
89
90 static void add_g1YoungGen_memory_pool(G1CollectedHeap* g1h,
91 MemoryManager* major_mgr,
92 MemoryManager* minor_mgr);
93 static void add_g1OldGen_memory_pool(G1CollectedHeap* g1h,
94 MemoryManager* mgr);
95
96 static void add_shenandoah_memory_pool(ShenandoahHeap* pgc,
97 MemoryManager* mgr);
98
99 static MemoryPool* add_space(ContiguousSpace* space,
100 const char* name,
101 bool is_heap,
102 size_t max_size,
103 bool support_usage_threshold);
104 static MemoryPool* add_survivor_spaces(DefNewGeneration* young_gen,
105 const char* name,
106 bool is_heap,
107 size_t max_size,
108 bool support_usage_threshold);
109 static MemoryPool* add_gen(Generation* gen,
110 const char* name,
111 bool is_heap,
112 bool support_usage_threshold);
113 static MemoryPool* add_cms_space(CompactibleFreeListSpace* space,
114 const char* name,
115 bool is_heap,
116 size_t max_size,
117 bool support_usage_threshold);
118
119 static void add_gen_collected_heap_info(GenCollectedHeap* heap);
120 static void add_parallel_scavenge_heap_info(ParallelScavengeHeap* heap);
121 static void add_g1_heap_info(G1CollectedHeap* g1h);
122 static void add_shenandoah_heap_info(ShenandoahHeap* heap);
123
124 public:
125 static void set_universe_heap(CollectedHeap* heap);
126 static void add_code_heap_memory_pool(CodeHeap* heap, const char* name);
127 static void add_metaspace_memory_pools();
128
129 static MemoryPool* get_memory_pool(instanceHandle pool);
130 static MemoryManager* get_memory_manager(instanceHandle mgr);
131
132 static const int num_memory_pools() {
133 return _pools_list->length();
134 }
135 static const int num_memory_managers() {
136 return _managers_list->length();
137 }
138
139 static MemoryPool* get_memory_pool(int index) {
140 return _pools_list->at(index);
141 }
142
|