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;
378 }
379
380 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h,
381 MemoryManager* mgr) {
382 assert(mgr != NULL, "should have one manager");
383
384 G1OldGenPool* old_gen = new G1OldGenPool(g1h);
385 mgr->add_pool(old_gen);
386 _pools_list->append(old_gen);
387 }
388 #endif // INCLUDE_ALL_GCS
389
390 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) {
391 _code_heap_pool = new CodeHeapPool(heap,
392 "Code Cache",
393 true /* support_usage_threshold */);
394 MemoryManager* mgr = MemoryManager::get_code_cache_memory_manager();
395 mgr->add_pool(_code_heap_pool);
396
397 _pools_list->append(_code_heap_pool);
398 _managers_list->append(mgr);
399 }
400
401 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
402 for (int i = 0; i < _managers_list->length(); i++) {
403 MemoryManager* mgr = _managers_list->at(i);
404 if (mgr->is_manager(mh)) {
405 return mgr;
406 }
407 }
408 return NULL;
409 }
410
411 MemoryPool* MemoryService::get_memory_pool(instanceHandle ph) {
412 for (int i = 0; i < _pools_list->length(); i++) {
413 MemoryPool* pool = _pools_list->at(i);
414 if (pool->is_pool(ph)) {
415 return pool;
416 }
417 }
|
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;
380 }
381
382 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h,
383 MemoryManager* mgr) {
384 assert(mgr != NULL, "should have one manager");
385
386 G1OldGenPool* old_gen = new G1OldGenPool(g1h);
387 mgr->add_pool(old_gen);
388 _pools_list->append(old_gen);
389 }
390 #endif // INCLUDE_ALL_GCS
391
392 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) {
393 _code_heap_pool = new CodeHeapPool(heap,
394 "Code Cache",
395 true /* support_usage_threshold */);
396 MemoryManager* mgr = MemoryManager::get_code_cache_memory_manager();
397 mgr->add_pool(_code_heap_pool);
398
399 _pools_list->append(_code_heap_pool);
400 _managers_list->append(mgr);
401 }
402
403 void MemoryService::add_metaspace_memory_pools() {
404 _metaspace_pool = new MetaspacePool();
405 _class_metaspace_pool = new ClassMetaspacePool();
406
407 MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
408 mgr->add_pool(_metaspace_pool);
409 mgr->add_pool(_class_metaspace_pool);
410
411 _pools_list->append(_metaspace_pool);
412 _pools_list->append(_class_metaspace_pool);
413 _managers_list->append(mgr);
414 }
415
416 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
417 for (int i = 0; i < _managers_list->length(); i++) {
418 MemoryManager* mgr = _managers_list->at(i);
419 if (mgr->is_manager(mh)) {
420 return mgr;
421 }
422 }
423 return NULL;
424 }
425
426 MemoryPool* MemoryService::get_memory_pool(instanceHandle ph) {
427 for (int i = 0; i < _pools_list->length(); i++) {
428 MemoryPool* pool = _pools_list->at(i);
429 if (pool->is_pool(ph)) {
430 return pool;
431 }
432 }
|