46 #include "utilities/growableArray.hpp"
47 #include "utilities/macros.hpp"
48 #if INCLUDE_ALL_GCS
49 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
50 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
51 #include "gc_implementation/parNew/parNewGeneration.hpp"
52 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
53 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
54 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
55 #include "services/g1MemoryPool.hpp"
56 #include "services/psMemoryPool.hpp"
57 #endif // INCLUDE_ALL_GCS
58
59 GrowableArray<MemoryPool*>* MemoryService::_pools_list =
60 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true);
61 GrowableArray<MemoryManager*>* MemoryService::_managers_list =
62 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true);
63
64 GCMemoryManager* MemoryService::_minor_gc_manager = NULL;
65 GCMemoryManager* MemoryService::_major_gc_manager = NULL;
66 MemoryPool* MemoryService::_code_heap_pool = NULL;
67 MemoryPool* MemoryService::_metaspace_pool = NULL;
68 MemoryPool* MemoryService::_compressed_class_pool = NULL;
69
70 class GcThreadCountClosure: public ThreadClosure {
71 private:
72 int _count;
73 public:
74 GcThreadCountClosure() : _count(0) {};
75 void do_thread(Thread* thread);
76 int count() { return _count; }
77 };
78
79 void GcThreadCountClosure::do_thread(Thread* thread) {
80 _count++;
81 }
82
83 void MemoryService::set_universe_heap(CollectedHeap* heap) {
84 CollectedHeap::Name kind = heap->kind();
85 switch (kind) {
86 case CollectedHeap::GenCollectedHeap : {
371 G1SurvivorPool* survivor = new G1SurvivorPool(g1h);
372
373 major_mgr->add_pool(eden);
374 major_mgr->add_pool(survivor);
375 minor_mgr->add_pool(eden);
376 minor_mgr->add_pool(survivor);
377 _pools_list->append(eden);
378 _pools_list->append(survivor);
379 }
380
381 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h,
382 MemoryManager* mgr) {
383 assert(mgr != NULL, "should have one manager");
384
385 G1OldGenPool* old_gen = new G1OldGenPool(g1h);
386 mgr->add_pool(old_gen);
387 _pools_list->append(old_gen);
388 }
389 #endif // INCLUDE_ALL_GCS
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 void MemoryService::add_metaspace_memory_pools() {
403 MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
404
405 _metaspace_pool = new MetaspacePool();
406 mgr->add_pool(_metaspace_pool);
407 _pools_list->append(_metaspace_pool);
408
409 if (UseCompressedClassPointers) {
410 _compressed_class_pool = new CompressedKlassSpacePool();
411 mgr->add_pool(_compressed_class_pool);
412 _pools_list->append(_compressed_class_pool);
413 }
414
415 _managers_list->append(mgr);
416 }
417
418 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
419 for (int i = 0; i < _managers_list->length(); i++) {
|
46 #include "utilities/growableArray.hpp"
47 #include "utilities/macros.hpp"
48 #if INCLUDE_ALL_GCS
49 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
50 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
51 #include "gc_implementation/parNew/parNewGeneration.hpp"
52 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
53 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
54 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
55 #include "services/g1MemoryPool.hpp"
56 #include "services/psMemoryPool.hpp"
57 #endif // INCLUDE_ALL_GCS
58
59 GrowableArray<MemoryPool*>* MemoryService::_pools_list =
60 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true);
61 GrowableArray<MemoryManager*>* MemoryService::_managers_list =
62 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true);
63
64 GCMemoryManager* MemoryService::_minor_gc_manager = NULL;
65 GCMemoryManager* MemoryService::_major_gc_manager = NULL;
66 MemoryManager* MemoryService::_code_cache_manager = NULL;
67 GrowableArray<MemoryPool*>* MemoryService::_code_heap_pools =
68 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_code_heap_pools_size, true);
69 MemoryPool* MemoryService::_metaspace_pool = NULL;
70 MemoryPool* MemoryService::_compressed_class_pool = NULL;
71
72 class GcThreadCountClosure: public ThreadClosure {
73 private:
74 int _count;
75 public:
76 GcThreadCountClosure() : _count(0) {};
77 void do_thread(Thread* thread);
78 int count() { return _count; }
79 };
80
81 void GcThreadCountClosure::do_thread(Thread* thread) {
82 _count++;
83 }
84
85 void MemoryService::set_universe_heap(CollectedHeap* heap) {
86 CollectedHeap::Name kind = heap->kind();
87 switch (kind) {
88 case CollectedHeap::GenCollectedHeap : {
373 G1SurvivorPool* survivor = new G1SurvivorPool(g1h);
374
375 major_mgr->add_pool(eden);
376 major_mgr->add_pool(survivor);
377 minor_mgr->add_pool(eden);
378 minor_mgr->add_pool(survivor);
379 _pools_list->append(eden);
380 _pools_list->append(survivor);
381 }
382
383 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h,
384 MemoryManager* mgr) {
385 assert(mgr != NULL, "should have one manager");
386
387 G1OldGenPool* old_gen = new G1OldGenPool(g1h);
388 mgr->add_pool(old_gen);
389 _pools_list->append(old_gen);
390 }
391 #endif // INCLUDE_ALL_GCS
392
393 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap, const char* name) {
394 // Create new memory pool for this heap
395 MemoryPool* code_heap_pool = new CodeHeapPool(heap, name, true /* support_usage_threshold */);
396
397 // Append to lists
398 _code_heap_pools->append(code_heap_pool);
399 _pools_list->append(code_heap_pool);
400
401 if (_code_cache_manager == NULL) {
402 // Create CodeCache memory manager
403 _code_cache_manager = MemoryManager::get_code_cache_memory_manager();
404 _managers_list->append(_code_cache_manager);
405 }
406
407 _code_cache_manager->add_pool(code_heap_pool);
408 }
409
410 void MemoryService::add_metaspace_memory_pools() {
411 MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
412
413 _metaspace_pool = new MetaspacePool();
414 mgr->add_pool(_metaspace_pool);
415 _pools_list->append(_metaspace_pool);
416
417 if (UseCompressedClassPointers) {
418 _compressed_class_pool = new CompressedKlassSpacePool();
419 mgr->add_pool(_compressed_class_pool);
420 _pools_list->append(_compressed_class_pool);
421 }
422
423 _managers_list->append(mgr);
424 }
425
426 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
427 for (int i = 0; i < _managers_list->length(); i++) {
|