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 : {
374 G1SurvivorPool* survivor = new G1SurvivorPool(g1h);
375
376 major_mgr->add_pool(eden);
377 major_mgr->add_pool(survivor);
378 minor_mgr->add_pool(eden);
379 minor_mgr->add_pool(survivor);
380 _pools_list->append(eden);
381 _pools_list->append(survivor);
382 }
383
384 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h,
385 MemoryManager* mgr) {
386 assert(mgr != NULL, "should have one manager");
387
388 G1OldGenPool* old_gen = new G1OldGenPool(g1h);
389 mgr->add_pool(old_gen);
390 _pools_list->append(old_gen);
391 }
392 #endif // INCLUDE_ALL_GCS
393
394 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) {
395 _code_heap_pool = new CodeHeapPool(heap,
396 "Code Cache",
397 true /* support_usage_threshold */);
398 MemoryManager* mgr = MemoryManager::get_code_cache_memory_manager();
399 mgr->add_pool(_code_heap_pool);
400
401 _pools_list->append(_code_heap_pool);
402 _managers_list->append(mgr);
403 }
404
405 void MemoryService::add_metaspace_memory_pools() {
406 MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
407
408 _metaspace_pool = new MetaspacePool();
409 mgr->add_pool(_metaspace_pool);
410 _pools_list->append(_metaspace_pool);
411
412 if (UseCompressedClassPointers) {
413 _compressed_class_pool = new CompressedKlassSpacePool();
414 mgr->add_pool(_compressed_class_pool);
415 _pools_list->append(_compressed_class_pool);
416 }
417
418 _managers_list->append(mgr);
419 }
420
421 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
422 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 : {
376 G1SurvivorPool* survivor = new G1SurvivorPool(g1h);
377
378 major_mgr->add_pool(eden);
379 major_mgr->add_pool(survivor);
380 minor_mgr->add_pool(eden);
381 minor_mgr->add_pool(survivor);
382 _pools_list->append(eden);
383 _pools_list->append(survivor);
384 }
385
386 void MemoryService::add_g1OldGen_memory_pool(G1CollectedHeap* g1h,
387 MemoryManager* mgr) {
388 assert(mgr != NULL, "should have one manager");
389
390 G1OldGenPool* old_gen = new G1OldGenPool(g1h);
391 mgr->add_pool(old_gen);
392 _pools_list->append(old_gen);
393 }
394 #endif // INCLUDE_ALL_GCS
395
396 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap, const char* name) {
397 // Create new memory pool for this heap
398 MemoryPool* code_heap_pool = new CodeHeapPool(heap, name, true /* support_usage_threshold */);
399
400 // Append to lists
401 _code_heap_pools->append(code_heap_pool);
402 _pools_list->append(code_heap_pool);
403
404 if (_code_cache_manager == NULL) {
405 // Create CodeCache memory manager
406 _code_cache_manager = MemoryManager::get_code_cache_memory_manager();
407 _managers_list->append(_code_cache_manager);
408 }
409
410 _code_cache_manager->add_pool(code_heap_pool);
411 }
412
413 void MemoryService::add_metaspace_memory_pools() {
414 MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
415
416 _metaspace_pool = new MetaspacePool();
417 mgr->add_pool(_metaspace_pool);
418 _pools_list->append(_metaspace_pool);
419
420 if (UseCompressedClassPointers) {
421 _compressed_class_pool = new CompressedKlassSpacePool();
422 mgr->add_pool(_compressed_class_pool);
423 _pools_list->append(_compressed_class_pool);
424 }
425
426 _managers_list->append(mgr);
427 }
428
429 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
430 for (int i = 0; i < _managers_list->length(); i++) {
|