Mercurial > hg > graal-compiler

comparison src/share/vm/services/memoryService.cpp @ 6725:da91efe96a93

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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);