18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/systemDictionary.hpp"
27 #include "classfile/vmSymbols.hpp"
28 #include "gc_implementation/shared/mutableSpace.hpp"
29 #include "memory/collectorPolicy.hpp"
30 #include "memory/defNewGeneration.hpp"
31 #include "memory/genCollectedHeap.hpp"
32 #include "memory/generation.hpp"
33 #include "memory/generationSpec.hpp"
34 #include "memory/heap.hpp"
35 #include "memory/memRegion.hpp"
36 #include "memory/tenuredGeneration.hpp"
37 #include "oops/oop.inline.hpp"
38 #include "runtime/javaCalls.hpp"
39 #include "services/classLoadingService.hpp"
40 #include "services/lowMemoryDetector.hpp"
41 #include "services/management.hpp"
42 #include "services/memoryManager.hpp"
43 #include "services/memoryPool.hpp"
44 #include "services/memoryService.hpp"
45 #include "utilities/growableArray.hpp"
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 }
|
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/systemDictionary.hpp"
27 #include "classfile/vmSymbols.hpp"
28 #include "gc_implementation/shared/mutableSpace.hpp"
29 #include "memory/collectorPolicy.hpp"
30 #include "memory/defNewGeneration.hpp"
31 #include "memory/genCollectedHeap.hpp"
32 #include "memory/generation.hpp"
33 #include "memory/generationSpec.hpp"
34 #include "memory/heap.hpp"
35 #include "memory/memRegion.hpp"
36 #include "memory/tenuredGeneration.hpp"
37 #include "oops/oop.inline.hpp"
38 #include "runtime/globals.hpp"
39 #include "runtime/javaCalls.hpp"
40 #include "services/classLoadingService.hpp"
41 #include "services/lowMemoryDetector.hpp"
42 #include "services/management.hpp"
43 #include "services/memoryManager.hpp"
44 #include "services/memoryPool.hpp"
45 #include "services/memoryService.hpp"
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 : {
87 add_gen_collected_heap_info(GenCollectedHeap::heap());
88 break;
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 (UseCompressedKlassPointers) {
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++) {
423 MemoryManager* mgr = _managers_list->at(i);
424 if (mgr->is_manager(mh)) {
425 return mgr;
426 }
427 }
428 return NULL;
429 }
430
431 MemoryPool* MemoryService::get_memory_pool(instanceHandle ph) {
432 for (int i = 0; i < _pools_list->length(); i++) {
433 MemoryPool* pool = _pools_list->at(i);
434 if (pool->is_pool(ph)) {
435 return pool;
436 }
437 }
|