Mercurial > hg > truffle
comparison src/share/vm/services/memoryService.cpp @ 6725:da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author | coleenp |
---|---|
date | Sat, 01 Sep 2012 13:25:18 -0400 |
parents | d2a62e0f25eb |
children | db9981fd3124 |
comparison
equal
deleted
inserted
replaced
6724:36d1d483d5d6 | 6725:da91efe96a93 |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. | 2 * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | 4 * |
5 * This code is free software; you can redistribute it and/or modify it | 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 | 6 * under the terms of the GNU General Public License version 2 only, as |
7 * published by the Free Software Foundation. | 7 * published by the Free Software Foundation. |
31 #include "memory/genCollectedHeap.hpp" | 31 #include "memory/genCollectedHeap.hpp" |
32 #include "memory/generation.hpp" | 32 #include "memory/generation.hpp" |
33 #include "memory/generationSpec.hpp" | 33 #include "memory/generationSpec.hpp" |
34 #include "memory/heap.hpp" | 34 #include "memory/heap.hpp" |
35 #include "memory/memRegion.hpp" | 35 #include "memory/memRegion.hpp" |
36 #include "memory/permGen.hpp" | |
37 #include "memory/tenuredGeneration.hpp" | 36 #include "memory/tenuredGeneration.hpp" |
38 #include "oops/oop.inline.hpp" | 37 #include "oops/oop.inline.hpp" |
39 #include "runtime/javaCalls.hpp" | 38 #include "runtime/javaCalls.hpp" |
40 #include "services/classLoadingService.hpp" | 39 #include "services/classLoadingService.hpp" |
41 #include "services/lowMemoryDetector.hpp" | 40 #include "services/lowMemoryDetector.hpp" |
43 #include "services/memoryManager.hpp" | 42 #include "services/memoryManager.hpp" |
44 #include "services/memoryPool.hpp" | 43 #include "services/memoryPool.hpp" |
45 #include "services/memoryService.hpp" | 44 #include "services/memoryService.hpp" |
46 #include "utilities/growableArray.hpp" | 45 #include "utilities/growableArray.hpp" |
47 #ifndef SERIALGC | 46 #ifndef SERIALGC |
48 #include "gc_implementation/concurrentMarkSweep/cmsPermGen.hpp" | |
49 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp" | 47 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp" |
50 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | 48 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
51 #include "gc_implementation/parNew/parNewGeneration.hpp" | 49 #include "gc_implementation/parNew/parNewGeneration.hpp" |
52 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" | 50 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" |
53 #include "gc_implementation/parallelScavenge/psOldGen.hpp" | 51 #include "gc_implementation/parallelScavenge/psOldGen.hpp" |
54 #include "gc_implementation/parallelScavenge/psPermGen.hpp" | |
55 #include "gc_implementation/parallelScavenge/psYoungGen.hpp" | 52 #include "gc_implementation/parallelScavenge/psYoungGen.hpp" |
56 #include "services/g1MemoryPool.hpp" | 53 #include "services/g1MemoryPool.hpp" |
57 #include "services/psMemoryPool.hpp" | 54 #include "services/psMemoryPool.hpp" |
58 #endif | 55 #endif |
59 | 56 |
158 _managers_list->append(_minor_gc_manager); | 155 _managers_list->append(_minor_gc_manager); |
159 _managers_list->append(_major_gc_manager); | 156 _managers_list->append(_major_gc_manager); |
160 | 157 |
161 add_generation_memory_pool(heap->get_gen(minor), _major_gc_manager, _minor_gc_manager); | 158 add_generation_memory_pool(heap->get_gen(minor), _major_gc_manager, _minor_gc_manager); |
162 add_generation_memory_pool(heap->get_gen(major), _major_gc_manager); | 159 add_generation_memory_pool(heap->get_gen(major), _major_gc_manager); |
163 | |
164 PermGen::Name name = policy->permanent_generation()->name(); | |
165 switch (name) { | |
166 case PermGen::MarkSweepCompact: { | |
167 CompactingPermGenGen* perm_gen = (CompactingPermGenGen*) heap->perm_gen(); | |
168 add_compact_perm_gen_memory_pool(perm_gen, _major_gc_manager); | |
169 break; | |
170 } | |
171 #ifndef SERIALGC | |
172 case PermGen::ConcurrentMarkSweep: { | |
173 CMSPermGenGen* cms_gen = (CMSPermGenGen*) heap->perm_gen(); | |
174 add_cms_perm_gen_memory_pool(cms_gen, _major_gc_manager); | |
175 break; | |
176 } | |
177 #endif // SERIALGC | |
178 default: | |
179 guarantee(false, "Unrecognized perm generation"); | |
180 break; | |
181 } | |
182 } | 160 } |
183 | 161 |
184 #ifndef SERIALGC | 162 #ifndef SERIALGC |
185 // Add memory pools for ParallelScavengeHeap | 163 // Add memory pools for ParallelScavengeHeap |
186 // This function currently only supports two generations collected heap. | 164 // This function currently only supports two generations collected heap. |
192 _managers_list->append(_minor_gc_manager); | 170 _managers_list->append(_minor_gc_manager); |
193 _managers_list->append(_major_gc_manager); | 171 _managers_list->append(_major_gc_manager); |
194 | 172 |
195 add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager); | 173 add_psYoung_memory_pool(heap->young_gen(), _major_gc_manager, _minor_gc_manager); |
196 add_psOld_memory_pool(heap->old_gen(), _major_gc_manager); | 174 add_psOld_memory_pool(heap->old_gen(), _major_gc_manager); |
197 add_psPerm_memory_pool(heap->perm_gen(), _major_gc_manager); | |
198 } | 175 } |
199 | 176 |
200 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) { | 177 void MemoryService::add_g1_heap_info(G1CollectedHeap* g1h) { |
201 assert(UseG1GC, "sanity"); | 178 assert(UseG1GC, "sanity"); |
202 | 179 |
205 _managers_list->append(_minor_gc_manager); | 182 _managers_list->append(_minor_gc_manager); |
206 _managers_list->append(_major_gc_manager); | 183 _managers_list->append(_major_gc_manager); |
207 | 184 |
208 add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager); | 185 add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager); |
209 add_g1OldGen_memory_pool(g1h, _major_gc_manager); | 186 add_g1OldGen_memory_pool(g1h, _major_gc_manager); |
210 add_g1PermGen_memory_pool(g1h, _major_gc_manager); | |
211 } | 187 } |
212 #endif // SERIALGC | 188 #endif // SERIALGC |
213 | 189 |
214 MemoryPool* MemoryService::add_gen(Generation* gen, | 190 MemoryPool* MemoryService::add_gen(Generation* gen, |
215 const char* name, | 191 const char* name, |
347 minor_mgr->add_pool(pool); | 323 minor_mgr->add_pool(pool); |
348 } | 324 } |
349 } | 325 } |
350 } | 326 } |
351 | 327 |
352 void MemoryService::add_compact_perm_gen_memory_pool(CompactingPermGenGen* perm_gen, | 328 |
353 MemoryManager* mgr) { | 329 #ifndef SERIALGC |
354 PermanentGenerationSpec* spec = perm_gen->spec(); | |
355 size_t max_size = spec->max_size() - spec->read_only_size() - spec->read_write_size(); | |
356 MemoryPool* pool = add_space(perm_gen->unshared_space(), | |
357 "Perm Gen", | |
358 false, /* is_heap */ | |
359 max_size, | |
360 true /* support_usage_threshold */); | |
361 mgr->add_pool(pool); | |
362 if (UseSharedSpaces) { | |
363 pool = add_space(perm_gen->ro_space(), | |
364 "Perm Gen [shared-ro]", | |
365 false, /* is_heap */ | |
366 spec->read_only_size(), | |
367 true /* support_usage_threshold */); | |
368 mgr->add_pool(pool); | |
369 | |
370 pool = add_space(perm_gen->rw_space(), | |
371 "Perm Gen [shared-rw]", | |
372 false, /* is_heap */ | |
373 spec->read_write_size(), | |
374 true /* support_usage_threshold */); | |
375 mgr->add_pool(pool); | |
376 } | |
377 } | |
378 | |
379 #ifndef SERIALGC | |
380 void MemoryService::add_cms_perm_gen_memory_pool(CMSPermGenGen* cms_gen, | |
381 MemoryManager* mgr) { | |
382 | |
383 MemoryPool* pool = add_cms_space(cms_gen->cmsSpace(), | |
384 "CMS Perm Gen", | |
385 false, /* is_heap */ | |
386 cms_gen->reserved().byte_size(), | |
387 true /* support_usage_threshold */); | |
388 mgr->add_pool(pool); | |
389 } | |
390 | |
391 void MemoryService::add_psYoung_memory_pool(PSYoungGen* gen, MemoryManager* major_mgr, MemoryManager* minor_mgr) { | 330 void MemoryService::add_psYoung_memory_pool(PSYoungGen* gen, MemoryManager* major_mgr, MemoryManager* minor_mgr) { |
392 assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers"); | 331 assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers"); |
393 | 332 |
394 // Add a memory pool for each space and young gen doesn't | 333 // Add a memory pool for each space and young gen doesn't |
395 // support low memory detection as it is expected to get filled up. | 334 // support low memory detection as it is expected to get filled up. |
419 true /* support_usage_threshold */); | 358 true /* support_usage_threshold */); |
420 mgr->add_pool(old_gen); | 359 mgr->add_pool(old_gen); |
421 _pools_list->append(old_gen); | 360 _pools_list->append(old_gen); |
422 } | 361 } |
423 | 362 |
424 void MemoryService::add_psPerm_memory_pool(PSPermGen* gen, MemoryManager* mgr) { | |
425 PSGenerationPool* perm_gen = new PSGenerationPool(gen, | |
426 "PS Perm Gen", | |
427 MemoryPool::NonHeap, | |
428 true /* support_usage_threshold */); | |
429 mgr->add_pool(perm_gen); | |
430 _pools_list->append(perm_gen); | |
431 } | |
432 | |
433 void MemoryService::add_g1YoungGen_memory_pool(G1CollectedHeap* g1h, | 363 void MemoryService::add_g1YoungGen_memory_pool(G1CollectedHeap* g1h, |
434 MemoryManager* major_mgr, | 364 MemoryManager* major_mgr, |
435 MemoryManager* minor_mgr) { | 365 MemoryManager* minor_mgr) { |
436 assert(major_mgr != NULL && minor_mgr != NULL, "should have two managers"); | 366 assert(major_mgr != NULL && minor_mgr != NULL, "should have two managers"); |
437 | 367 |
452 | 382 |
453 G1OldGenPool* old_gen = new G1OldGenPool(g1h); | 383 G1OldGenPool* old_gen = new G1OldGenPool(g1h); |
454 mgr->add_pool(old_gen); | 384 mgr->add_pool(old_gen); |
455 _pools_list->append(old_gen); | 385 _pools_list->append(old_gen); |
456 } | 386 } |
457 | |
458 void MemoryService::add_g1PermGen_memory_pool(G1CollectedHeap* g1h, | |
459 MemoryManager* mgr) { | |
460 assert(mgr != NULL, "should have one manager"); | |
461 | |
462 CompactingPermGenGen* perm_gen = (CompactingPermGenGen*) g1h->perm_gen(); | |
463 PermanentGenerationSpec* spec = perm_gen->spec(); | |
464 size_t max_size = spec->max_size() - spec->read_only_size() | |
465 - spec->read_write_size(); | |
466 MemoryPool* pool = add_space(perm_gen->unshared_space(), | |
467 "G1 Perm Gen", | |
468 false, /* is_heap */ | |
469 max_size, | |
470 true /* support_usage_threshold */); | |
471 mgr->add_pool(pool); | |
472 | |
473 // in case we support CDS in G1 | |
474 if (UseSharedSpaces) { | |
475 pool = add_space(perm_gen->ro_space(), | |
476 "G1 Perm Gen [shared-ro]", | |
477 false, /* is_heap */ | |
478 spec->read_only_size(), | |
479 true /* support_usage_threshold */); | |
480 mgr->add_pool(pool); | |
481 | |
482 pool = add_space(perm_gen->rw_space(), | |
483 "G1 Perm Gen [shared-rw]", | |
484 false, /* is_heap */ | |
485 spec->read_write_size(), | |
486 true /* support_usage_threshold */); | |
487 mgr->add_pool(pool); | |
488 } | |
489 } | |
490 #endif // SERIALGC | 387 #endif // SERIALGC |
491 | 388 |
492 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) { | 389 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) { |
493 _code_heap_pool = new CodeHeapPool(heap, | 390 _code_heap_pool = new CodeHeapPool(heap, |
494 "Code Cache", | 391 "Code Cache", |
603 | 500 |
604 return verbose; | 501 return verbose; |
605 } | 502 } |
606 | 503 |
607 Handle MemoryService::create_MemoryUsage_obj(MemoryUsage usage, TRAPS) { | 504 Handle MemoryService::create_MemoryUsage_obj(MemoryUsage usage, TRAPS) { |
608 klassOop k = Management::java_lang_management_MemoryUsage_klass(CHECK_NH); | 505 Klass* k = Management::java_lang_management_MemoryUsage_klass(CHECK_NH); |
609 instanceKlassHandle ik(THREAD, k); | 506 instanceKlassHandle ik(THREAD, k); |
610 | 507 |
611 instanceHandle obj = ik->allocate_instance_handle(CHECK_NH); | 508 instanceHandle obj = ik->allocate_instance_handle(CHECK_NH); |
612 | 509 |
613 JavaValue result(T_VOID); | 510 JavaValue result(T_VOID); |