109 heap->gc_threads_do(&gctcc);
110 int count = gctcc.count();
111 if (count > 0) {
112 _minor_gc_manager->set_num_gc_threads(count);
113 _major_gc_manager->set_num_gc_threads(count);
114 }
115
116 // All memory pools and memory managers are initialized.
117 //
118 _minor_gc_manager->initialize_gc_stat_info();
119 _major_gc_manager->initialize_gc_stat_info();
120 }
121
122 // Add memory pools for GenCollectedHeap
123 // This function currently only supports two generations collected heap.
124 // The collector for GenCollectedHeap will have two memory managers.
125 void MemoryService::add_gen_collected_heap_info(GenCollectedHeap* heap) {
126 CollectorPolicy* policy = heap->collector_policy();
127
128 assert(policy->is_generation_policy(), "Only support two generations");
129 guarantee(heap->n_gens() == 2, "Only support two-generation heap");
130
131 GenCollectorPolicy* gen_policy = policy->as_generation_policy();
132 if (gen_policy != NULL) {
133 GenerationSpec** specs = gen_policy->generations();
134 Generation::Name kind = specs[0]->name();
135 switch (kind) {
136 case Generation::DefNew:
137 _minor_gc_manager = MemoryManager::get_copy_memory_manager();
138 break;
139 #if INCLUDE_ALL_GCS
140 case Generation::ParNew:
141 _minor_gc_manager = MemoryManager::get_parnew_memory_manager();
142 break;
143 #endif // INCLUDE_ALL_GCS
144 default:
145 guarantee(false, "Unrecognized generation spec");
146 break;
147 }
148 if (policy->is_mark_sweep_policy()) {
149 _major_gc_manager = MemoryManager::get_msc_memory_manager();
150 #if INCLUDE_ALL_GCS
151 } else if (policy->is_concurrent_mark_sweep_policy()) {
152 _major_gc_manager = MemoryManager::get_cms_memory_manager();
153 #endif // INCLUDE_ALL_GCS
154 } else {
155 guarantee(false, "Unknown two-gen policy");
156 }
157 } else {
158 guarantee(false, "Non two-gen policy");
159 }
160 _managers_list->append(_minor_gc_manager);
161 _managers_list->append(_major_gc_manager);
162
163 add_generation_memory_pool(heap->get_gen(minor), _major_gc_manager, _minor_gc_manager);
164 add_generation_memory_pool(heap->get_gen(major), _major_gc_manager);
165 }
166
167 #if INCLUDE_ALL_GCS
168 // Add memory pools for ParallelScavengeHeap
169 // This function currently only supports two generations collected heap.
170 // The collector for ParallelScavengeHeap will have two memory managers.
171 void MemoryService::add_parallel_scavenge_heap_info(ParallelScavengeHeap* heap) {
172 // Two managers to keep statistics about _minor_gc_manager and _major_gc_manager GC.
173 _minor_gc_manager = MemoryManager::get_psScavenge_memory_manager();
174 _major_gc_manager = MemoryManager::get_psMarkSweep_memory_manager();
175 _managers_list->append(_minor_gc_manager);
176 _managers_list->append(_major_gc_manager);
177
178 add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager);
179 add_psOld_memory_pool(heap->old_gen(), _major_gc_manager);
180 }
181
182 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) {
183 assert(UseG1GC, "sanity");
184
|
109 heap->gc_threads_do(&gctcc);
110 int count = gctcc.count();
111 if (count > 0) {
112 _minor_gc_manager->set_num_gc_threads(count);
113 _major_gc_manager->set_num_gc_threads(count);
114 }
115
116 // All memory pools and memory managers are initialized.
117 //
118 _minor_gc_manager->initialize_gc_stat_info();
119 _major_gc_manager->initialize_gc_stat_info();
120 }
121
122 // Add memory pools for GenCollectedHeap
123 // This function currently only supports two generations collected heap.
124 // The collector for GenCollectedHeap will have two memory managers.
125 void MemoryService::add_gen_collected_heap_info(GenCollectedHeap* heap) {
126 CollectorPolicy* policy = heap->collector_policy();
127
128 assert(policy->is_generation_policy(), "Only support two generations");
129 GenCollectorPolicy* gen_policy = policy->as_generation_policy();
130 guarantee(gen_policy->number_of_generations() == 2, "Only support two-generation heap");
131 if (gen_policy != NULL) {
132 Generation::Name kind = gen_policy->young_gen_spec()->name();
133 switch (kind) {
134 case Generation::DefNew:
135 _minor_gc_manager = MemoryManager::get_copy_memory_manager();
136 break;
137 #if INCLUDE_ALL_GCS
138 case Generation::ParNew:
139 _minor_gc_manager = MemoryManager::get_parnew_memory_manager();
140 break;
141 #endif // INCLUDE_ALL_GCS
142 default:
143 guarantee(false, "Unrecognized generation spec");
144 break;
145 }
146 if (policy->is_mark_sweep_policy()) {
147 _major_gc_manager = MemoryManager::get_msc_memory_manager();
148 #if INCLUDE_ALL_GCS
149 } else if (policy->is_concurrent_mark_sweep_policy()) {
150 _major_gc_manager = MemoryManager::get_cms_memory_manager();
151 #endif // INCLUDE_ALL_GCS
152 } else {
153 guarantee(false, "Unknown two-gen policy");
154 }
155 } else {
156 guarantee(false, "Non two-gen policy");
157 }
158 _managers_list->append(_minor_gc_manager);
159 _managers_list->append(_major_gc_manager);
160
161 add_generation_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager);
162 add_generation_memory_pool(heap->old_gen(), _major_gc_manager);
163 }
164
165 #if INCLUDE_ALL_GCS
166 // Add memory pools for ParallelScavengeHeap
167 // This function currently only supports two generations collected heap.
168 // The collector for ParallelScavengeHeap will have two memory managers.
169 void MemoryService::add_parallel_scavenge_heap_info(ParallelScavengeHeap* heap) {
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
|