32 #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp"
33 #include "gc_implementation/parallelScavenge/psMarkSweep.hpp"
34 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
35 #include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
36 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
37 #include "gc_implementation/parallelScavenge/vmPSOperations.hpp"
38 #include "gc_implementation/shared/gcHeapSummary.hpp"
39 #include "gc_implementation/shared/gcWhen.hpp"
40 #include "memory/gcLocker.inline.hpp"
41 #include "oops/oop.inline.hpp"
42 #include "runtime/handles.inline.hpp"
43 #include "runtime/java.hpp"
44 #include "runtime/vmThread.hpp"
45 #include "services/memTracker.hpp"
46 #include "utilities/vmError.hpp"
47
48 PSYoungGen* ParallelScavengeHeap::_young_gen = NULL;
49 PSOldGen* ParallelScavengeHeap::_old_gen = NULL;
50 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
51 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
52 ParallelScavengeHeap* ParallelScavengeHeap::_psh = NULL;
53 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
54
55 jint ParallelScavengeHeap::initialize() {
56 CollectedHeap::pre_initialize();
57
58 // Initialize collector policy
59 _collector_policy = new GenerationSizer();
60 _collector_policy->initialize_all();
61
62 const size_t heap_size = _collector_policy->max_heap_byte_size();
63
64 ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->heap_alignment());
65 MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtJavaHeap);
66
67 os::trace_page_sizes("ps main", _collector_policy->min_heap_byte_size(),
68 heap_size, generation_alignment(),
69 heap_rs.base(),
70 heap_rs.size());
71 if (!heap_rs.is_reserved()) {
72 vm_shutdown_during_initialization(
73 "Could not reserve enough space for object heap");
74 return JNI_ENOMEM;
75 }
76
77 initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
78
79 CardTableExtension* const barrier_set = new CardTableExtension(reserved_region());
80 barrier_set->initialize();
81 set_barrier_set(barrier_set);
82
83 // Make up the generations
84 // Calculate the maximum size that a generation can grow. This
85 // includes growth into the other generation. Note that the
86 // parameter _max_gen_size is kept as the maximum
87 // size of the generation as the boundaries currently stand.
88 // _max_gen_size is still used as that value.
89 double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
90 double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
91
92 _psh = this;
93 _gens = new AdjoiningGenerations(heap_rs, _collector_policy, generation_alignment());
94
95 _old_gen = _gens->old_gen();
96 _young_gen = _gens->young_gen();
97
98 const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes();
99 const size_t old_capacity = _old_gen->capacity_in_bytes();
100 const size_t initial_promo_size = MIN2(eden_capacity, old_capacity);
101 _size_policy =
102 new PSAdaptiveSizePolicy(eden_capacity,
103 initial_promo_size,
104 young_gen()->to_space()->capacity_in_bytes(),
105 _collector_policy->gen_alignment(),
106 max_gc_pause_sec,
107 max_gc_minor_pause_sec,
108 GCTimeRatio
109 );
110
111 assert(!UseAdaptiveGCBoundary ||
112 (old_gen()->virtual_space()->high_boundary() ==
633 "->" SIZE_FORMAT
634 "(" SIZE_FORMAT ")",
635 prev_used, used(), capacity());
636 } else {
637 gclog_or_tty->print(" " SIZE_FORMAT "K"
638 "->" SIZE_FORMAT "K"
639 "(" SIZE_FORMAT "K)",
640 prev_used / K, used() / K, capacity() / K);
641 }
642 }
643
644 void ParallelScavengeHeap::trace_heap(GCWhen::Type when, const GCTracer* gc_tracer) {
645 const PSHeapSummary& heap_summary = create_ps_heap_summary();
646 gc_tracer->report_gc_heap_summary(when, heap_summary);
647
648 const MetaspaceSummary& metaspace_summary = create_metaspace_summary();
649 gc_tracer->report_metaspace_summary(when, metaspace_summary);
650 }
651
652 ParallelScavengeHeap* ParallelScavengeHeap::heap() {
653 assert(_psh != NULL, "Uninitialized access to ParallelScavengeHeap::heap()");
654 assert(_psh->kind() == CollectedHeap::ParallelScavengeHeap, "not a parallel scavenge heap");
655 return _psh;
656 }
657
658 // Before delegating the resize to the young generation,
659 // the reserved space for the young and old generations
660 // may be changed to accommodate the desired resize.
661 void ParallelScavengeHeap::resize_young_gen(size_t eden_size,
662 size_t survivor_size) {
663 if (UseAdaptiveGCBoundary) {
664 if (size_policy()->bytes_absorbed_from_eden() != 0) {
665 size_policy()->reset_bytes_absorbed_from_eden();
666 return; // The generation changed size already.
667 }
668 gens()->adjust_boundary_for_young_gen_needs(eden_size, survivor_size);
669 }
670
671 // Delegate the resize to the generation.
672 _young_gen->resize(eden_size, survivor_size);
673 }
674
675 // Before delegating the resize to the old generation,
|
32 #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp"
33 #include "gc_implementation/parallelScavenge/psMarkSweep.hpp"
34 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
35 #include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
36 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
37 #include "gc_implementation/parallelScavenge/vmPSOperations.hpp"
38 #include "gc_implementation/shared/gcHeapSummary.hpp"
39 #include "gc_implementation/shared/gcWhen.hpp"
40 #include "memory/gcLocker.inline.hpp"
41 #include "oops/oop.inline.hpp"
42 #include "runtime/handles.inline.hpp"
43 #include "runtime/java.hpp"
44 #include "runtime/vmThread.hpp"
45 #include "services/memTracker.hpp"
46 #include "utilities/vmError.hpp"
47
48 PSYoungGen* ParallelScavengeHeap::_young_gen = NULL;
49 PSOldGen* ParallelScavengeHeap::_old_gen = NULL;
50 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
51 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
52 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
53
54 jint ParallelScavengeHeap::initialize() {
55 CollectedHeap::pre_initialize();
56
57 // Initialize collector policy
58 _collector_policy = new GenerationSizer();
59 _collector_policy->initialize_all();
60
61 const size_t heap_size = _collector_policy->max_heap_byte_size();
62
63 ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->heap_alignment());
64 MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtJavaHeap);
65
66 os::trace_page_sizes("ps main", _collector_policy->min_heap_byte_size(),
67 heap_size, generation_alignment(),
68 heap_rs.base(),
69 heap_rs.size());
70 if (!heap_rs.is_reserved()) {
71 vm_shutdown_during_initialization(
72 "Could not reserve enough space for object heap");
73 return JNI_ENOMEM;
74 }
75
76 initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
77
78 CardTableExtension* const barrier_set = new CardTableExtension(reserved_region());
79 barrier_set->initialize();
80 set_barrier_set(barrier_set);
81
82 // Make up the generations
83 // Calculate the maximum size that a generation can grow. This
84 // includes growth into the other generation. Note that the
85 // parameter _max_gen_size is kept as the maximum
86 // size of the generation as the boundaries currently stand.
87 // _max_gen_size is still used as that value.
88 double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
89 double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
90
91 _gens = new AdjoiningGenerations(heap_rs, _collector_policy, generation_alignment());
92
93 _old_gen = _gens->old_gen();
94 _young_gen = _gens->young_gen();
95
96 const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes();
97 const size_t old_capacity = _old_gen->capacity_in_bytes();
98 const size_t initial_promo_size = MIN2(eden_capacity, old_capacity);
99 _size_policy =
100 new PSAdaptiveSizePolicy(eden_capacity,
101 initial_promo_size,
102 young_gen()->to_space()->capacity_in_bytes(),
103 _collector_policy->gen_alignment(),
104 max_gc_pause_sec,
105 max_gc_minor_pause_sec,
106 GCTimeRatio
107 );
108
109 assert(!UseAdaptiveGCBoundary ||
110 (old_gen()->virtual_space()->high_boundary() ==
631 "->" SIZE_FORMAT
632 "(" SIZE_FORMAT ")",
633 prev_used, used(), capacity());
634 } else {
635 gclog_or_tty->print(" " SIZE_FORMAT "K"
636 "->" SIZE_FORMAT "K"
637 "(" SIZE_FORMAT "K)",
638 prev_used / K, used() / K, capacity() / K);
639 }
640 }
641
642 void ParallelScavengeHeap::trace_heap(GCWhen::Type when, const GCTracer* gc_tracer) {
643 const PSHeapSummary& heap_summary = create_ps_heap_summary();
644 gc_tracer->report_gc_heap_summary(when, heap_summary);
645
646 const MetaspaceSummary& metaspace_summary = create_metaspace_summary();
647 gc_tracer->report_metaspace_summary(when, metaspace_summary);
648 }
649
650 ParallelScavengeHeap* ParallelScavengeHeap::heap() {
651 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
652 assert(heap != NULL, "Uninitialized access to ParallelScavengeHeap::heap()");
653 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Not a ParallelScavengeHeap");
654 return heap;
655 }
656
657 // Before delegating the resize to the young generation,
658 // the reserved space for the young and old generations
659 // may be changed to accommodate the desired resize.
660 void ParallelScavengeHeap::resize_young_gen(size_t eden_size,
661 size_t survivor_size) {
662 if (UseAdaptiveGCBoundary) {
663 if (size_policy()->bytes_absorbed_from_eden() != 0) {
664 size_policy()->reset_bytes_absorbed_from_eden();
665 return; // The generation changed size already.
666 }
667 gens()->adjust_boundary_for_young_gen_needs(eden_size, survivor_size);
668 }
669
670 // Delegate the resize to the generation.
671 _young_gen->resize(eden_size, survivor_size);
672 }
673
674 // Before delegating the resize to the old generation,
|