46 #include "utilities/macros.hpp"
47 #if INCLUDE_ALL_GCS
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"
56 #endif // INCLUDE_ALL_GCS
57
58 GrowableArray<MemoryPool*>* MemoryService::_pools_list =
59 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true);
60 GrowableArray<MemoryManager*>* MemoryService::_managers_list =
61 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true);
62
63 GCMemoryManager* MemoryService::_minor_gc_manager = NULL;
64 GCMemoryManager* MemoryService::_major_gc_manager = NULL;
65 MemoryPool* MemoryService::_code_heap_pool = NULL;
66 MemoryPool* MemoryService::_metaspace_pool = NULL;
67 MemoryPool* MemoryService::_class_metaspace_pool = NULL;
68
69 class GcThreadCountClosure: public ThreadClosure {
70 private:
71 int _count;
72 public:
73 GcThreadCountClosure() : _count(0) {};
74 void do_thread(Thread* thread);
75 int count() { return _count; }
76 };
77
78 void GcThreadCountClosure::do_thread(Thread* thread) {
79 _count++;
80 }
81
82 void MemoryService::set_universe_heap(CollectedHeap* heap) {
83 CollectedHeap::Name kind = heap->kind();
84 switch (kind) {
85 case CollectedHeap::GenCollectedHeap : {
86 add_gen_collected_heap_info(GenCollectedHeap::heap());
87 break;
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) {
394 _code_heap_pool = new CodeHeapPool(heap,
395 "Code Cache",
396 true /* support_usage_threshold */);
397 MemoryManager* mgr = MemoryManager::get_code_cache_memory_manager();
398 mgr->add_pool(_code_heap_pool);
399
400 _pools_list->append(_code_heap_pool);
401 _managers_list->append(mgr);
402 }
403
404 void MemoryService::add_metaspace_memory_pools() {
405 _metaspace_pool = new MetaspacePool();
406 _class_metaspace_pool = new ClassMetaspacePool();
407
408 MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
409 mgr->add_pool(_metaspace_pool);
410 mgr->add_pool(_class_metaspace_pool);
411
412 _pools_list->append(_metaspace_pool);
413 _pools_list->append(_class_metaspace_pool);
414 _managers_list->append(mgr);
415 }
416
417 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
418 for (int i = 0; i < _managers_list->length(); i++) {
419 MemoryManager* mgr = _managers_list->at(i);
420 if (mgr->is_manager(mh)) {
421 return mgr;
422 }
423 }
424 return NULL;
425 }
426
427 MemoryPool* MemoryService::get_memory_pool(instanceHandle ph) {
428 for (int i = 0; i < _pools_list->length(); i++) {
429 MemoryPool* pool = _pools_list->at(i);
430 if (pool->is_pool(ph)) {
431 return pool;
432 }
433 }
|
46 #include "utilities/macros.hpp"
47 #if INCLUDE_ALL_GCS
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"
56 #endif // INCLUDE_ALL_GCS
57
58 GrowableArray<MemoryPool*>* MemoryService::_pools_list =
59 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true);
60 GrowableArray<MemoryManager*>* MemoryService::_managers_list =
61 new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true);
62
63 GCMemoryManager* MemoryService::_minor_gc_manager = NULL;
64 GCMemoryManager* MemoryService::_major_gc_manager = NULL;
65 MemoryPool* MemoryService::_code_heap_pool = NULL;
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;
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 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 }
|