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 static void trace_gen_sizes(const char* const str, 56 size_t og_min, size_t og_max, 57 size_t yg_min, size_t yg_max) 58 { 59 if (TracePageSizes) { 60 tty->print_cr("%s: " SIZE_FORMAT "," SIZE_FORMAT " " 61 SIZE_FORMAT "," SIZE_FORMAT " " 62 SIZE_FORMAT, 63 str, 64 og_min / K, og_max / K, 65 yg_min / K, yg_max / K, 66 (og_max + yg_max) / K); 67 } 68 } 69 70 jint ParallelScavengeHeap::initialize() { 71 CollectedHeap::pre_initialize(); 72 73 // Cannot be initialized until after the flags are parsed 74 // GenerationSizer flag_parser; 75 _collector_policy = new GenerationSizer(); 76 77 size_t yg_min_size = _collector_policy->min_young_gen_size(); 78 size_t yg_max_size = _collector_policy->max_young_gen_size(); 79 size_t og_min_size = _collector_policy->min_old_gen_size(); 80 size_t og_max_size = _collector_policy->max_old_gen_size(); 81 82 trace_gen_sizes("ps heap raw", 83 og_min_size, og_max_size, 84 yg_min_size, yg_max_size); 85 86 const size_t og_page_sz = os::page_size_for_region(yg_min_size + og_min_size, 87 yg_max_size + og_max_size, 88 8); 89 90 const size_t og_align = set_alignment(_old_gen_alignment, og_page_sz); 91 const size_t yg_align = set_alignment(_young_gen_alignment, og_page_sz); 92 93 // Update sizes to reflect the selected page size(s). 94 // 95 // NEEDS_CLEANUP. The default TwoGenerationCollectorPolicy uses NewRatio; it 96 // should check UseAdaptiveSizePolicy. Changes from generationSizer could 97 // move to the common code. 98 yg_min_size = align_size_up(yg_min_size, yg_align); 99 yg_max_size = align_size_up(yg_max_size, yg_align); 100 size_t yg_cur_size = 101 align_size_up(_collector_policy->young_gen_size(), yg_align); 102 yg_cur_size = MAX2(yg_cur_size, yg_min_size); 103 104 og_min_size = align_size_up(og_min_size, og_align); 105 // Align old gen size down to preserve specified heap size. 106 assert(og_align == yg_align, "sanity"); 107 og_max_size = align_size_down(og_max_size, og_align); 108 og_max_size = MAX2(og_max_size, og_min_size); 109 size_t og_cur_size = 110 align_size_down(_collector_policy->old_gen_size(), og_align); 111 og_cur_size = MAX2(og_cur_size, og_min_size); 112 113 trace_gen_sizes("ps heap rnd", 114 og_min_size, og_max_size, 115 yg_min_size, yg_max_size); 116 117 const size_t heap_size = og_max_size + yg_max_size; 118 119 ReservedSpace heap_rs = Universe::reserve_heap(heap_size, og_align); 120 121 MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtJavaHeap); 122 123 os::trace_page_sizes("ps main", og_min_size + yg_min_size, 124 og_max_size + yg_max_size, og_page_sz, 125 heap_rs.base(), 126 heap_rs.size()); 127 if (!heap_rs.is_reserved()) { 128 vm_shutdown_during_initialization( 129 "Could not reserve enough space for object heap"); 130 return JNI_ENOMEM; 131 } 132 133 _reserved = MemRegion((HeapWord*)heap_rs.base(), 134 (HeapWord*)(heap_rs.base() + heap_rs.size())); 135 136 CardTableExtension* const barrier_set = new CardTableExtension(_reserved, 3); 137 _barrier_set = barrier_set; 138 oopDesc::set_bs(_barrier_set); 139 if (_barrier_set == NULL) { 140 vm_shutdown_during_initialization( 141 "Could not reserve enough space for barrier set"); 142 return JNI_ENOMEM; 143 } 144 145 // Initial young gen size is 4 Mb 146 // 147 // XXX - what about flag_parser.young_gen_size()? 148 const size_t init_young_size = align_size_up(4 * M, yg_align); 149 yg_cur_size = MAX2(MIN2(init_young_size, yg_max_size), yg_cur_size); 150 151 // Make up the generations 152 // Calculate the maximum size that a generation can grow. This 153 // includes growth into the other generation. Note that the 154 // parameter _max_gen_size is kept as the maximum 155 // size of the generation as the boundaries currently stand. 156 // _max_gen_size is still used as that value. 157 double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0; 158 double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0; 159 160 _gens = new AdjoiningGenerations(heap_rs, 161 og_cur_size, 162 og_min_size, 163 og_max_size, 164 yg_cur_size, 165 yg_min_size, 166 yg_max_size, 167 yg_align); 168 169 _old_gen = _gens->old_gen(); 170 _young_gen = _gens->young_gen(); 171 172 const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes(); 173 const size_t old_capacity = _old_gen->capacity_in_bytes(); 174 const size_t initial_promo_size = MIN2(eden_capacity, old_capacity); 175 _size_policy = 176 new PSAdaptiveSizePolicy(eden_capacity, 177 initial_promo_size, 178 young_gen()->to_space()->capacity_in_bytes(), 179 intra_heap_alignment(), 180 max_gc_pause_sec, 181 max_gc_minor_pause_sec, 182 GCTimeRatio 183 ); 184 185 assert(!UseAdaptiveGCBoundary || 186 (old_gen()->virtual_space()->high_boundary() == 187 young_gen()->virtual_space()->low_boundary()), | 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 size_t ParallelScavengeHeap::intra_heap_alignment() { 56 return GenCollectorPolicy::intra_heap_alignment(); 57 } 58 59 size_t ParallelScavengeHeap::alignment() { 60 return collector_policy()->min_alignment(); 61 } 62 63 jint ParallelScavengeHeap::initialize() { 64 CollectedHeap::pre_initialize(); 65 66 // Initialize collector policy 67 _collector_policy = new GenerationSizer(); 68 69 const size_t heap_size = _collector_policy->max_heap_byte_size(); 70 71 ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->max_alignment()); 72 MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtJavaHeap); 73 74 os::trace_page_sizes("ps main", _collector_policy->min_heap_byte_size(), 75 heap_size, alignment(), 76 heap_rs.base(), 77 heap_rs.size()); 78 if (!heap_rs.is_reserved()) { 79 vm_shutdown_during_initialization( 80 "Could not reserve enough space for object heap"); 81 return JNI_ENOMEM; 82 } 83 84 _reserved = MemRegion((HeapWord*)heap_rs.base(), 85 (HeapWord*)(heap_rs.base() + heap_rs.size())); 86 87 CardTableExtension* const barrier_set = new CardTableExtension(_reserved, 3); 88 _barrier_set = barrier_set; 89 oopDesc::set_bs(_barrier_set); 90 if (_barrier_set == NULL) { 91 vm_shutdown_during_initialization( 92 "Could not reserve enough space for barrier set"); 93 return JNI_ENOMEM; 94 } 95 96 // Make up the generations 97 // Calculate the maximum size that a generation can grow. This 98 // includes growth into the other generation. Note that the 99 // parameter _max_gen_size is kept as the maximum 100 // size of the generation as the boundaries currently stand. 101 // _max_gen_size is still used as that value. 102 double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0; 103 double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0; 104 105 _gens = new AdjoiningGenerations(heap_rs, _collector_policy, alignment()); 106 107 _old_gen = _gens->old_gen(); 108 _young_gen = _gens->young_gen(); 109 110 const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes(); 111 const size_t old_capacity = _old_gen->capacity_in_bytes(); 112 const size_t initial_promo_size = MIN2(eden_capacity, old_capacity); 113 _size_policy = 114 new PSAdaptiveSizePolicy(eden_capacity, 115 initial_promo_size, 116 young_gen()->to_space()->capacity_in_bytes(), 117 intra_heap_alignment(), 118 max_gc_pause_sec, 119 max_gc_minor_pause_sec, 120 GCTimeRatio 121 ); 122 123 assert(!UseAdaptiveGCBoundary || 124 (old_gen()->virtual_space()->high_boundary() == 125 young_gen()->virtual_space()->low_boundary()), |