Mercurial > hg > graal-compiler
annotate src/share/vm/services/memoryService.cpp @ 10185:d50cc62e94ff
8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t
Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime.
Reviewed-by: twisti, johnc
Contributed-by: Martin Doerr <martin.doerr@sap.com>
| author | johnc |
|---|---|
| date | Wed, 24 Apr 2013 14:48:43 -0700 |
| parents | 42e370795a39 |
| children | 71963b3f802a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
2 * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1089
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1089
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1089
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "classfile/vmSymbols.hpp" | |
| 28 #include "gc_implementation/shared/mutableSpace.hpp" | |
| 29 #include "memory/collectorPolicy.hpp" | |
| 30 #include "memory/defNewGeneration.hpp" | |
| 31 #include "memory/genCollectedHeap.hpp" | |
| 32 #include "memory/generation.hpp" | |
| 33 #include "memory/generationSpec.hpp" | |
| 34 #include "memory/heap.hpp" | |
| 35 #include "memory/memRegion.hpp" | |
| 36 #include "memory/tenuredGeneration.hpp" | |
| 37 #include "oops/oop.inline.hpp" | |
| 38 #include "runtime/javaCalls.hpp" | |
| 39 #include "services/classLoadingService.hpp" | |
| 40 #include "services/lowMemoryDetector.hpp" | |
| 41 #include "services/management.hpp" | |
| 42 #include "services/memoryManager.hpp" | |
| 43 #include "services/memoryPool.hpp" | |
| 44 #include "services/memoryService.hpp" | |
| 45 #include "utilities/growableArray.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
46 #include "utilities/macros.hpp" |
|
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
47 #if INCLUDE_ALL_GCS |
| 1972 | 48 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp" |
| 49 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
| 50 #include "gc_implementation/parNew/parNewGeneration.hpp" | |
| 51 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" | |
| 52 #include "gc_implementation/parallelScavenge/psOldGen.hpp" | |
| 53 #include "gc_implementation/parallelScavenge/psYoungGen.hpp" | |
| 54 #include "services/g1MemoryPool.hpp" | |
| 55 #include "services/psMemoryPool.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
56 #endif // INCLUDE_ALL_GCS |
| 0 | 57 |
| 58 GrowableArray<MemoryPool*>* MemoryService::_pools_list = | |
| 6197 | 59 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true); |
| 0 | 60 GrowableArray<MemoryManager*>* MemoryService::_managers_list = |
| 6197 | 61 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true); |
| 0 | 62 |
| 8827 | 63 GCMemoryManager* MemoryService::_minor_gc_manager = NULL; |
| 64 GCMemoryManager* MemoryService::_major_gc_manager = NULL; | |
| 65 MemoryPool* MemoryService::_code_heap_pool = NULL; | |
| 0 | 66 |
| 67 class GcThreadCountClosure: public ThreadClosure { | |
| 68 private: | |
| 69 int _count; | |
| 70 public: | |
| 71 GcThreadCountClosure() : _count(0) {}; | |
| 72 void do_thread(Thread* thread); | |
| 73 int count() { return _count; } | |
| 74 }; | |
| 75 | |
| 76 void GcThreadCountClosure::do_thread(Thread* thread) { | |
| 77 _count++; | |
| 78 } | |
| 79 | |
| 80 void MemoryService::set_universe_heap(CollectedHeap* heap) { | |
| 81 CollectedHeap::Name kind = heap->kind(); | |
| 82 switch (kind) { | |
| 83 case CollectedHeap::GenCollectedHeap : { | |
| 84 add_gen_collected_heap_info(GenCollectedHeap::heap()); | |
| 85 break; | |
| 86 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
87 #if INCLUDE_ALL_GCS |
| 0 | 88 case CollectedHeap::ParallelScavengeHeap : { |
| 89 add_parallel_scavenge_heap_info(ParallelScavengeHeap::heap()); | |
| 90 break; | |
| 91 } | |
| 342 | 92 case CollectedHeap::G1CollectedHeap : { |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
93 add_g1_heap_info(G1CollectedHeap::heap()); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
94 break; |
| 342 | 95 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
96 #endif // INCLUDE_ALL_GCS |
| 0 | 97 default: { |
| 342 | 98 guarantee(false, "Unrecognized kind of heap"); |
| 0 | 99 } |
| 100 } | |
| 101 | |
| 102 // set the GC thread count | |
| 103 GcThreadCountClosure gctcc; | |
| 104 heap->gc_threads_do(&gctcc); | |
| 105 int count = gctcc.count(); | |
| 106 if (count > 0) { | |
| 107 _minor_gc_manager->set_num_gc_threads(count); | |
| 108 _major_gc_manager->set_num_gc_threads(count); | |
| 109 } | |
| 110 | |
| 111 // All memory pools and memory managers are initialized. | |
| 112 // | |
| 113 _minor_gc_manager->initialize_gc_stat_info(); | |
| 114 _major_gc_manager->initialize_gc_stat_info(); | |
| 115 } | |
| 116 | |
| 117 // Add memory pools for GenCollectedHeap | |
| 118 // This function currently only supports two generations collected heap. | |
| 119 // The collector for GenCollectedHeap will have two memory managers. | |
| 120 void MemoryService::add_gen_collected_heap_info(GenCollectedHeap* heap) { | |
| 121 CollectorPolicy* policy = heap->collector_policy(); | |
| 122 | |
| 123 assert(policy->is_two_generation_policy(), "Only support two generations"); | |
| 124 guarantee(heap->n_gens() == 2, "Only support two-generation heap"); | |
| 125 | |
| 126 TwoGenerationCollectorPolicy* two_gen_policy = policy->as_two_generation_policy(); | |
| 127 if (two_gen_policy != NULL) { | |
| 128 GenerationSpec** specs = two_gen_policy->generations(); | |
| 129 Generation::Name kind = specs[0]->name(); | |
| 130 switch (kind) { | |
| 131 case Generation::DefNew: | |
| 132 _minor_gc_manager = MemoryManager::get_copy_memory_manager(); | |
| 133 break; | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
134 #if INCLUDE_ALL_GCS |
| 0 | 135 case Generation::ParNew: |
| 136 case Generation::ASParNew: | |
| 137 _minor_gc_manager = MemoryManager::get_parnew_memory_manager(); | |
| 138 break; | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
139 #endif // INCLUDE_ALL_GCS |
| 0 | 140 default: |
| 141 guarantee(false, "Unrecognized generation spec"); | |
| 142 break; | |
| 143 } | |
| 144 if (policy->is_mark_sweep_policy()) { | |
| 145 _major_gc_manager = MemoryManager::get_msc_memory_manager(); | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
146 #if INCLUDE_ALL_GCS |
| 0 | 147 } else if (policy->is_concurrent_mark_sweep_policy()) { |
| 148 _major_gc_manager = MemoryManager::get_cms_memory_manager(); | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
149 #endif // INCLUDE_ALL_GCS |
| 0 | 150 } else { |
| 151 guarantee(false, "Unknown two-gen policy"); | |
| 152 } | |
| 153 } else { | |
| 154 guarantee(false, "Non two-gen policy"); | |
| 155 } | |
| 156 _managers_list->append(_minor_gc_manager); | |
| 157 _managers_list->append(_major_gc_manager); | |
| 158 | |
| 159 add_generation_memory_pool(heap->get_gen(minor), _major_gc_manager, _minor_gc_manager); | |
| 160 add_generation_memory_pool(heap->get_gen(major), _major_gc_manager); | |
| 161 } | |
| 162 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
163 #if INCLUDE_ALL_GCS |
| 0 | 164 // Add memory pools for ParallelScavengeHeap |
| 165 // This function currently only supports two generations collected heap. | |
| 166 // The collector for ParallelScavengeHeap will have two memory managers. | |
| 167 void MemoryService::add_parallel_scavenge_heap_info(ParallelScavengeHeap* heap) { | |
| 168 // Two managers to keep statistics about _minor_gc_manager and _major_gc_manager GC. | |
| 169 _minor_gc_manager = MemoryManager::get_psScavenge_memory_manager(); | |
| 170 _major_gc_manager = MemoryManager::get_psMarkSweep_memory_manager(); | |
| 171 _managers_list->append(_minor_gc_manager); | |
| 172 _managers_list->append(_major_gc_manager); | |
| 173 | |
| 174 add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager); | |
| 175 add_psOld_memory_pool(heap->old_gen(), _major_gc_manager); | |
| 176 } | |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
177 |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
178 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) { |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
179 assert(UseG1GC, "sanity"); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
180 |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
181 _minor_gc_manager = MemoryManager::get_g1YoungGen_memory_manager(); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
182 _major_gc_manager = MemoryManager::get_g1OldGen_memory_manager(); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
183 _managers_list->append(_minor_gc_manager); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
184 _managers_list->append(_major_gc_manager); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
185 |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
186 add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
187 add_g1OldGen_memory_pool(g1h, _major_gc_manager); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
188 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
189 #endif // INCLUDE_ALL_GCS |
| 0 | 190 |
| 191 MemoryPool* MemoryService::add_gen(Generation* gen, | |
| 192 const char* name, | |
| 193 bool is_heap, | |
| 194 bool support_usage_threshold) { | |
| 195 | |
| 196 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap); | |
| 197 GenerationPool* pool = new GenerationPool(gen, name, type, support_usage_threshold); | |
| 198 _pools_list->append(pool); | |
| 199 return (MemoryPool*) pool; | |
| 200 } | |
| 201 | |
| 202 MemoryPool* MemoryService::add_space(ContiguousSpace* space, | |
| 203 const char* name, | |
| 204 bool is_heap, | |
| 205 size_t max_size, | |
| 206 bool support_usage_threshold) { | |
| 207 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap); | |
| 208 ContiguousSpacePool* pool = new ContiguousSpacePool(space, name, type, max_size, support_usage_threshold); | |
| 209 | |
| 210 _pools_list->append(pool); | |
| 211 return (MemoryPool*) pool; | |
| 212 } | |
| 213 | |
| 214 MemoryPool* MemoryService::add_survivor_spaces(DefNewGeneration* gen, | |
| 215 const char* name, | |
| 216 bool is_heap, | |
| 217 size_t max_size, | |
| 218 bool support_usage_threshold) { | |
| 219 MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap); | |
| 220 SurvivorContiguousSpacePool* pool = new SurvivorContiguousSpacePool(gen, name, type, max_size, support_usage_threshold); | |
| 221 | |
| 222 _pools_list->append(pool); | |
| 223 return (MemoryPool*) pool; | |
| 224 } | |
| 225 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
226 #if INCLUDE_ALL_GCS |
| 0 | 227 MemoryPool* MemoryService::add_cms_space(CompactibleFreeListSpace* 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); | |
| 233 CompactibleFreeListSpacePool* pool = new CompactibleFreeListSpacePool(space, name, type, max_size, support_usage_threshold); | |
| 234 _pools_list->append(pool); | |
| 235 return (MemoryPool*) pool; | |
| 236 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
237 #endif // INCLUDE_ALL_GCS |
| 0 | 238 |
| 239 // Add memory pool(s) for one generation | |
| 240 void MemoryService::add_generation_memory_pool(Generation* gen, | |
| 241 MemoryManager* major_mgr, | |
| 242 MemoryManager* minor_mgr) { | |
|
8761
8b4ce9870fd6
8009156: [parfait] Null pointer deference in hotspot/src/share/vm/services/memoryService.cpp
morris
parents:
8001
diff
changeset
|
243 guarantee(gen != NULL, "No generation for memory pool"); |
| 0 | 244 Generation::Name kind = gen->kind(); |
| 245 int index = _pools_list->length(); | |
| 246 | |
| 247 switch (kind) { | |
| 248 case Generation::DefNew: { | |
| 249 assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers"); | |
| 250 DefNewGeneration* young_gen = (DefNewGeneration*) gen; | |
| 251 // Add a memory pool for each space and young gen doesn't | |
| 252 // support low memory detection as it is expected to get filled up. | |
| 253 MemoryPool* eden = add_space(young_gen->eden(), | |
| 254 "Eden Space", | |
| 255 true, /* is_heap */ | |
| 256 young_gen->max_eden_size(), | |
| 257 false /* support_usage_threshold */); | |
| 258 MemoryPool* survivor = add_survivor_spaces(young_gen, | |
| 259 "Survivor Space", | |
| 260 true, /* is_heap */ | |
| 261 young_gen->max_survivor_size(), | |
| 262 false /* support_usage_threshold */); | |
| 263 break; | |
| 264 } | |
| 265 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
266 #if INCLUDE_ALL_GCS |
| 0 | 267 case Generation::ParNew: |
| 268 case Generation::ASParNew: | |
| 269 { | |
| 270 assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers"); | |
| 271 // Add a memory pool for each space and young gen doesn't | |
| 272 // support low memory detection as it is expected to get filled up. | |
| 273 ParNewGeneration* parnew_gen = (ParNewGeneration*) gen; | |
| 274 MemoryPool* eden = add_space(parnew_gen->eden(), | |
| 275 "Par Eden Space", | |
| 276 true /* is_heap */, | |
| 277 parnew_gen->max_eden_size(), | |
| 278 false /* support_usage_threshold */); | |
| 279 MemoryPool* survivor = add_survivor_spaces(parnew_gen, | |
| 280 "Par Survivor Space", | |
| 281 true, /* is_heap */ | |
| 282 parnew_gen->max_survivor_size(), | |
| 283 false /* support_usage_threshold */); | |
| 284 | |
| 285 break; | |
| 286 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
287 #endif // INCLUDE_ALL_GCS |
| 0 | 288 |
| 289 case Generation::MarkSweepCompact: { | |
| 290 assert(major_mgr != NULL && minor_mgr == NULL, "Should have only one manager"); | |
| 291 add_gen(gen, | |
| 292 "Tenured Gen", | |
| 293 true, /* is_heap */ | |
| 294 true /* support_usage_threshold */); | |
| 295 break; | |
| 296 } | |
| 297 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
298 #if INCLUDE_ALL_GCS |
| 0 | 299 case Generation::ConcurrentMarkSweep: |
| 300 case Generation::ASConcurrentMarkSweep: | |
| 301 { | |
| 302 assert(major_mgr != NULL && minor_mgr == NULL, "Should have only one manager"); | |
| 303 ConcurrentMarkSweepGeneration* cms = (ConcurrentMarkSweepGeneration*) gen; | |
| 304 MemoryPool* pool = add_cms_space(cms->cmsSpace(), | |
| 305 "CMS Old Gen", | |
| 306 true, /* is_heap */ | |
| 307 cms->reserved().byte_size(), | |
| 308 true /* support_usage_threshold */); | |
| 309 break; | |
| 310 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
311 #endif // INCLUDE_ALL_GCS |
| 0 | 312 |
| 313 default: | |
| 314 assert(false, "should not reach here"); | |
| 315 // no memory pool added for others | |
| 316 break; | |
| 317 } | |
| 318 | |
| 319 assert(major_mgr != NULL, "Should have at least one manager"); | |
| 320 // Link managers and the memory pools together | |
| 321 for (int i = index; i < _pools_list->length(); i++) { | |
| 322 MemoryPool* pool = _pools_list->at(i); | |
| 323 major_mgr->add_pool(pool); | |
| 324 if (minor_mgr != NULL) { | |
| 325 minor_mgr->add_pool(pool); | |
| 326 } | |
| 327 } | |
| 328 } | |
| 329 | |
| 330 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
331 #if INCLUDE_ALL_GCS |
| 0 | 332 void MemoryService::add_psYoung_memory_pool(PSYoungGen* gen, MemoryManager* major_mgr, MemoryManager* minor_mgr) { |
| 333 assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers"); | |
| 334 | |
| 335 // Add a memory pool for each space and young gen doesn't | |
| 336 // support low memory detection as it is expected to get filled up. | |
| 337 EdenMutableSpacePool* eden = new EdenMutableSpacePool(gen, | |
| 338 gen->eden_space(), | |
| 339 "PS Eden Space", | |
| 340 MemoryPool::Heap, | |
| 341 false /* support_usage_threshold */); | |
| 342 | |
| 343 SurvivorMutableSpacePool* survivor = new SurvivorMutableSpacePool(gen, | |
| 344 "PS Survivor Space", | |
| 345 MemoryPool::Heap, | |
| 346 false /* support_usage_threshold */); | |
| 347 | |
| 348 major_mgr->add_pool(eden); | |
| 349 major_mgr->add_pool(survivor); | |
| 350 minor_mgr->add_pool(eden); | |
| 351 minor_mgr->add_pool(survivor); | |
| 352 _pools_list->append(eden); | |
| 353 _pools_list->append(survivor); | |
| 354 } | |
| 355 | |
| 356 void MemoryService::add_psOld_memory_pool(PSOldGen* gen, MemoryManager* mgr) { | |
| 357 PSGenerationPool* old_gen = new PSGenerationPool(gen, | |
| 358 "PS Old Gen", | |
| 359 MemoryPool::Heap, | |
| 360 true /* support_usage_threshold */); | |
| 361 mgr->add_pool(old_gen); | |
| 362 _pools_list->append(old_gen); | |
| 363 } | |
| 364 | |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
365 void MemoryService::add_g1YoungGen_memory_pool(G1CollectedHeap* g1h, |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
366 MemoryManager* major_mgr, |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
367 MemoryManager* minor_mgr) { |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
368 assert(major_mgr != NULL && minor_mgr != NULL, "should have two managers"); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
369 |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
370 G1EdenPool* eden = new G1EdenPool(g1h); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
371 G1SurvivorPool* survivor = new G1SurvivorPool(g1h); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
372 |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
373 major_mgr->add_pool(eden); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
374 major_mgr->add_pool(survivor); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
375 minor_mgr->add_pool(eden); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
376 minor_mgr->add_pool(survivor); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
377 _pools_list->append(eden); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
378 _pools_list->append(survivor); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
379 } |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
380 |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
381 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h, |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
382 MemoryManager* mgr) { |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
383 assert(mgr != NULL, "should have one manager"); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
384 |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
385 G1OldGenPool* old_gen = new G1OldGenPool(g1h); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
386 mgr->add_pool(old_gen); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
387 _pools_list->append(old_gen); |
|
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
342
diff
changeset
|
388 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
389 #endif // INCLUDE_ALL_GCS |
| 0 | 390 |
| 391 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) { | |
| 392 _code_heap_pool = new CodeHeapPool(heap, | |
| 393 "Code Cache", | |
| 394 true /* support_usage_threshold */); | |
| 395 MemoryManager* mgr = MemoryManager::get_code_cache_memory_manager(); | |
| 396 mgr->add_pool(_code_heap_pool); | |
| 397 | |
| 398 _pools_list->append(_code_heap_pool); | |
| 399 _managers_list->append(mgr); | |
| 400 } | |
| 401 | |
| 402 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) { | |
| 403 for (int i = 0; i < _managers_list->length(); i++) { | |
| 404 MemoryManager* mgr = _managers_list->at(i); | |
| 405 if (mgr->is_manager(mh)) { | |
| 406 return mgr; | |
| 407 } | |
| 408 } | |
| 409 return NULL; | |
| 410 } | |
| 411 | |
| 412 MemoryPool* MemoryService::get_memory_pool(instanceHandle ph) { | |
| 413 for (int i = 0; i < _pools_list->length(); i++) { | |
| 414 MemoryPool* pool = _pools_list->at(i); | |
| 415 if (pool->is_pool(ph)) { | |
| 416 return pool; | |
| 417 } | |
| 418 } | |
| 419 return NULL; | |
| 420 } | |
| 421 | |
| 422 void MemoryService::track_memory_usage() { | |
| 423 // Track the peak memory usage | |
| 424 for (int i = 0; i < _pools_list->length(); i++) { | |
| 425 MemoryPool* pool = _pools_list->at(i); | |
| 426 pool->record_peak_memory_usage(); | |
| 427 } | |
| 428 | |
| 429 // Detect low memory | |
| 430 LowMemoryDetector::detect_low_memory(); | |
| 431 } | |
| 432 | |
| 433 void MemoryService::track_memory_pool_usage(MemoryPool* pool) { | |
| 434 // Track the peak memory usage | |
| 435 pool->record_peak_memory_usage(); | |
| 436 | |
| 437 // Detect low memory | |
| 438 if (LowMemoryDetector::is_enabled(pool)) { | |
| 439 LowMemoryDetector::detect_low_memory(pool); | |
| 440 } | |
| 441 } | |
| 442 | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
443 void MemoryService::gc_begin(bool fullGC, bool recordGCBeginTime, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
444 bool recordAccumulatedGCTime, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
445 bool recordPreGCUsage, bool recordPeakUsage) { |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
446 |
| 0 | 447 GCMemoryManager* mgr; |
| 448 if (fullGC) { | |
| 449 mgr = _major_gc_manager; | |
| 450 } else { | |
| 451 mgr = _minor_gc_manager; | |
| 452 } | |
| 453 assert(mgr->is_gc_memory_manager(), "Sanity check"); | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
454 mgr->gc_begin(recordGCBeginTime, recordPreGCUsage, recordAccumulatedGCTime); |
| 0 | 455 |
| 456 // Track the peak memory usage when GC begins | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
457 if (recordPeakUsage) { |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
458 for (int i = 0; i < _pools_list->length(); i++) { |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
459 MemoryPool* pool = _pools_list->at(i); |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
460 pool->record_peak_memory_usage(); |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
461 } |
| 0 | 462 } |
| 463 } | |
| 464 | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
465 void MemoryService::gc_end(bool fullGC, bool recordPostGCUsage, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
466 bool recordAccumulatedGCTime, |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
467 bool recordGCEndTime, bool countCollection, |
|
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
468 GCCause::Cause cause) { |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
469 |
| 0 | 470 GCMemoryManager* mgr; |
| 471 if (fullGC) { | |
| 472 mgr = (GCMemoryManager*) _major_gc_manager; | |
| 473 } else { | |
| 474 mgr = (GCMemoryManager*) _minor_gc_manager; | |
| 475 } | |
| 476 assert(mgr->is_gc_memory_manager(), "Sanity check"); | |
| 477 | |
| 478 // register the GC end statistics and memory usage | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
479 mgr->gc_end(recordPostGCUsage, recordAccumulatedGCTime, recordGCEndTime, |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
480 countCollection, cause); |
| 0 | 481 } |
| 482 | |
| 483 void MemoryService::oops_do(OopClosure* f) { | |
| 484 int i; | |
| 485 | |
| 486 for (i = 0; i < _pools_list->length(); i++) { | |
| 487 MemoryPool* pool = _pools_list->at(i); | |
| 488 pool->oops_do(f); | |
| 489 } | |
| 490 for (i = 0; i < _managers_list->length(); i++) { | |
| 491 MemoryManager* mgr = _managers_list->at(i); | |
| 492 mgr->oops_do(f); | |
| 493 } | |
| 494 } | |
| 495 | |
| 496 bool MemoryService::set_verbose(bool verbose) { | |
| 497 MutexLocker m(Management_lock); | |
| 498 // verbose will be set to the previous value | |
| 499 bool succeed = CommandLineFlags::boolAtPut((char*)"PrintGC", &verbose, MANAGEMENT); | |
| 500 assert(succeed, "Setting PrintGC flag fails"); | |
| 501 ClassLoadingService::reset_trace_class_unloading(); | |
| 502 | |
| 503 return verbose; | |
| 504 } | |
| 505 | |
| 506 Handle MemoryService::create_MemoryUsage_obj(MemoryUsage usage, TRAPS) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
507 Klass* k = Management::java_lang_management_MemoryUsage_klass(CHECK_NH); |
| 0 | 508 instanceKlassHandle ik(THREAD, k); |
| 509 | |
| 510 instanceHandle obj = ik->allocate_instance_handle(CHECK_NH); | |
| 511 | |
| 512 JavaValue result(T_VOID); | |
| 513 JavaCallArguments args(10); | |
| 514 args.push_oop(obj); // receiver | |
| 515 args.push_long(usage.init_size_as_jlong()); // Argument 1 | |
| 516 args.push_long(usage.used_as_jlong()); // Argument 2 | |
| 517 args.push_long(usage.committed_as_jlong()); // Argument 3 | |
| 518 args.push_long(usage.max_size_as_jlong()); // Argument 4 | |
| 519 | |
| 520 JavaCalls::call_special(&result, | |
| 521 ik, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
522 vmSymbols::object_initializer_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
523 vmSymbols::long_long_long_long_void_signature(), |
| 0 | 524 &args, |
| 525 CHECK_NH); | |
| 526 return obj; | |
| 527 } | |
| 528 // | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
529 // GC manager type depends on the type of Generation. Depending on the space |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
530 // availablity and vm options the gc uses major gc manager or minor gc |
| 0 | 531 // manager or both. The type of gc manager depends on the generation kind. |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
532 // For DefNew, ParNew and ASParNew generation doing scavenge gc uses minor |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
533 // gc manager (so _fullGC is set to false ) and for other generation kinds |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
534 // doing mark-sweep-compact uses major gc manager (so _fullGC is set |
| 0 | 535 // to true). |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
536 TraceMemoryManagerStats::TraceMemoryManagerStats(Generation::Name kind, GCCause::Cause cause) { |
| 0 | 537 switch (kind) { |
| 538 case Generation::DefNew: | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
539 #if INCLUDE_ALL_GCS |
| 0 | 540 case Generation::ParNew: |
| 541 case Generation::ASParNew: | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
542 #endif // INCLUDE_ALL_GCS |
| 0 | 543 _fullGC=false; |
| 544 break; | |
| 545 case Generation::MarkSweepCompact: | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
546 #if INCLUDE_ALL_GCS |
| 0 | 547 case Generation::ConcurrentMarkSweep: |
| 548 case Generation::ASConcurrentMarkSweep: | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6725
diff
changeset
|
549 #endif // INCLUDE_ALL_GCS |
| 0 | 550 _fullGC=true; |
| 551 break; | |
| 552 default: | |
| 553 assert(false, "Unrecognized gc generation kind."); | |
| 554 } | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
555 // this has to be called in a stop the world pause and represent |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
556 // an entire gc pause, start to finish: |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
557 initialize(_fullGC, cause,true, true, true, true, true, true, true); |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
558 } |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
559 TraceMemoryManagerStats::TraceMemoryManagerStats(bool fullGC, |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
560 GCCause::Cause cause, |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
561 bool recordGCBeginTime, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
562 bool recordPreGCUsage, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
563 bool recordPeakUsage, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
564 bool recordPostGCUsage, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
565 bool recordAccumulatedGCTime, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
566 bool recordGCEndTime, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
567 bool countCollection) { |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
568 initialize(fullGC, cause, recordGCBeginTime, recordPreGCUsage, recordPeakUsage, |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
569 recordPostGCUsage, recordAccumulatedGCTime, recordGCEndTime, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
570 countCollection); |
| 0 | 571 } |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
572 |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
573 // for a subclass to create then initialize an instance before invoking |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
574 // the MemoryService |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
575 void TraceMemoryManagerStats::initialize(bool fullGC, |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
576 GCCause::Cause cause, |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
577 bool recordGCBeginTime, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
578 bool recordPreGCUsage, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
579 bool recordPeakUsage, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
580 bool recordPostGCUsage, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
581 bool recordAccumulatedGCTime, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
582 bool recordGCEndTime, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
583 bool countCollection) { |
| 0 | 584 _fullGC = fullGC; |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
585 _recordGCBeginTime = recordGCBeginTime; |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
586 _recordPreGCUsage = recordPreGCUsage; |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
587 _recordPeakUsage = recordPeakUsage; |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
588 _recordPostGCUsage = recordPostGCUsage; |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
589 _recordAccumulatedGCTime = recordAccumulatedGCTime; |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
590 _recordGCEndTime = recordGCEndTime; |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
591 _countCollection = countCollection; |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
592 _cause = cause; |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
593 |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
594 MemoryService::gc_begin(_fullGC, _recordGCBeginTime, _recordAccumulatedGCTime, |
|
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
595 _recordPreGCUsage, _recordPeakUsage); |
| 0 | 596 } |
| 597 | |
| 598 TraceMemoryManagerStats::~TraceMemoryManagerStats() { | |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
599 MemoryService::gc_end(_fullGC, _recordPostGCUsage, _recordAccumulatedGCTime, |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
2426
diff
changeset
|
600 _recordGCEndTime, _countCollection, _cause); |
| 0 | 601 } |
|
1703
f6f3eef8a521
6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents:
1552
diff
changeset
|
602 |