Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp @ 13060:8f07aa079343

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking 7057939: jmap shows MaxNewSize=4GB when Java is using parallel collector Summary: Major cleanup of the collectorpolicy classes Reviewed-by: tschatzl, jcoomes
author jwilhelm
date Fri, 01 Nov 2013 17:09:38 +0100
parents 1a8fb39bdbc4
children ff355e26c78d cfd4aac53239
comparison
equal deleted inserted replaced
13059:46d7652b223c 13060:8f07aa079343
50 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL; 50 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
51 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL; 51 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
52 ParallelScavengeHeap* ParallelScavengeHeap::_psh = NULL; 52 ParallelScavengeHeap* ParallelScavengeHeap::_psh = NULL;
53 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL; 53 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
54 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() { 55 jint ParallelScavengeHeap::initialize() {
71 CollectedHeap::pre_initialize(); 56 CollectedHeap::pre_initialize();
72 57
73 // Cannot be initialized until after the flags are parsed 58 // Initialize collector policy
74 // GenerationSizer flag_parser;
75 _collector_policy = new GenerationSizer(); 59 _collector_policy = new GenerationSizer();
76 60 _collector_policy->initialize_all();
77 size_t yg_min_size = _collector_policy->min_young_gen_size(); 61
78 size_t yg_max_size = _collector_policy->max_young_gen_size(); 62 const size_t heap_size = _collector_policy->max_heap_byte_size();
79 size_t og_min_size = _collector_policy->min_old_gen_size(); 63
80 size_t og_max_size = _collector_policy->max_old_gen_size(); 64 ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->heap_alignment());
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); 65 MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtJavaHeap);
122 66
123 os::trace_page_sizes("ps main", og_min_size + yg_min_size, 67 os::trace_page_sizes("ps main", _collector_policy->min_heap_byte_size(),
124 og_max_size + yg_max_size, og_page_sz, 68 heap_size, generation_alignment(),
125 heap_rs.base(), 69 heap_rs.base(),
126 heap_rs.size()); 70 heap_rs.size());
127 if (!heap_rs.is_reserved()) { 71 if (!heap_rs.is_reserved()) {
128 vm_shutdown_during_initialization( 72 vm_shutdown_during_initialization(
129 "Could not reserve enough space for object heap"); 73 "Could not reserve enough space for object heap");
139 if (_barrier_set == NULL) { 83 if (_barrier_set == NULL) {
140 vm_shutdown_during_initialization( 84 vm_shutdown_during_initialization(
141 "Could not reserve enough space for barrier set"); 85 "Could not reserve enough space for barrier set");
142 return JNI_ENOMEM; 86 return JNI_ENOMEM;
143 } 87 }
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 88
151 // Make up the generations 89 // Make up the generations
152 // Calculate the maximum size that a generation can grow. This 90 // Calculate the maximum size that a generation can grow. This
153 // includes growth into the other generation. Note that the 91 // includes growth into the other generation. Note that the
154 // parameter _max_gen_size is kept as the maximum 92 // parameter _max_gen_size is kept as the maximum
155 // size of the generation as the boundaries currently stand. 93 // size of the generation as the boundaries currently stand.
156 // _max_gen_size is still used as that value. 94 // _max_gen_size is still used as that value.
157 double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0; 95 double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
158 double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0; 96 double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
159 97
160 _gens = new AdjoiningGenerations(heap_rs, 98 _gens = new AdjoiningGenerations(heap_rs, _collector_policy, generation_alignment());
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 99
169 _old_gen = _gens->old_gen(); 100 _old_gen = _gens->old_gen();
170 _young_gen = _gens->young_gen(); 101 _young_gen = _gens->young_gen();
171 102
172 const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes(); 103 const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes();
174 const size_t initial_promo_size = MIN2(eden_capacity, old_capacity); 105 const size_t initial_promo_size = MIN2(eden_capacity, old_capacity);
175 _size_policy = 106 _size_policy =
176 new PSAdaptiveSizePolicy(eden_capacity, 107 new PSAdaptiveSizePolicy(eden_capacity,
177 initial_promo_size, 108 initial_promo_size,
178 young_gen()->to_space()->capacity_in_bytes(), 109 young_gen()->to_space()->capacity_in_bytes(),
179 intra_heap_alignment(), 110 _collector_policy->gen_alignment(),
180 max_gc_pause_sec, 111 max_gc_pause_sec,
181 max_gc_minor_pause_sec, 112 max_gc_minor_pause_sec,
182 GCTimeRatio 113 GCTimeRatio
183 ); 114 );
184 115