author | shade |
Mon, 21 May 2018 14:50:28 +0200 | |
branch | epsilon-gc-branch |
changeset 56582 | c75a617df2f8 |
parent 56581 | d6ace215b52c |
child 56596 | e4e901df90f8 |
permissions | -rw-r--r-- |
55767 | 1 |
/* |
56350 | 2 |
* Copyright (c) 2017, 2018, Red Hat, Inc. All rights reserved. |
55767 | 3 |
* |
4 |
* This code is free software; you can redistribute it and/or modify it |
|
5 |
* under the terms of the GNU General Public License version 2 only, as |
|
6 |
* published by the Free Software Foundation. |
|
7 |
* |
|
8 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
9 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
10 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
11 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
12 |
* accompanied this code). |
|
13 |
* |
|
14 |
* You should have received a copy of the GNU General Public License version |
|
15 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
16 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
17 |
* |
|
18 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
19 |
* or visit www.oracle.com if you need additional information or have any |
|
20 |
* questions. |
|
21 |
* |
|
22 |
*/ |
|
23 |
||
24 |
#include "precompiled.hpp" |
|
55939 | 25 |
#include "gc/epsilon/epsilonHeap.hpp" |
55974 | 26 |
#include "gc/epsilon/epsilonMemoryPool.hpp" |
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
27 |
#include "gc/epsilon/epsilonThreadLocalData.hpp" |
56354 | 28 |
#include "memory/allocation.hpp" |
29 |
#include "memory/allocation.inline.hpp" |
|
30 |
#include "memory/resourceArea.hpp" |
|
55767 | 31 |
|
55939 | 32 |
jint EpsilonHeap::initialize() { |
55767 | 33 |
size_t init_byte_size = _policy->initial_heap_byte_size(); |
56581 | 34 |
size_t max_byte_size = _policy->max_heap_byte_size(); |
55767 | 35 |
|
56581 | 36 |
// Initialize backing storage |
37 |
ReservedSpace heap_rs = Universe::reserve_heap(max_byte_size, _policy->heap_alignment()); |
|
55767 | 38 |
_virtual_space.initialize(heap_rs, init_byte_size); |
39 |
||
56581 | 40 |
MemRegion committed_region((HeapWord*)_virtual_space.low(), (HeapWord*)_virtual_space.high()); |
41 |
MemRegion reserved_region((HeapWord*)_virtual_space.low_boundary(), (HeapWord*)_virtual_space.high_boundary()); |
|
55767 | 42 |
|
43 |
initialize_reserved_region(reserved_region.start(), reserved_region.end()); |
|
44 |
||
45 |
_space = new ContiguousSpace(); |
|
56582 | 46 |
_space->initialize(committed_region, /* clear_space = */ true, /* mangle_space = */ true); |
55767 | 47 |
|
56581 | 48 |
// Precompute hot fields |
49 |
_max_tlab_size = MIN2(CollectedHeap::max_tlab_size(), EpsilonMaxTLABSize / HeapWordSize); |
|
50 |
_step_counter_update = MIN2<size_t>(max_byte_size / 16, EpsilonUpdateCountersStep); |
|
51 |
_step_heap_print = (EpsilonPrintHeapStep == 0) ? SIZE_MAX : (max_byte_size / EpsilonPrintHeapStep); |
|
52 |
_decay_time_ns = (int64_t) EpsilonTLABDecayTime * 1000 * 1000; |
|
55767 | 53 |
|
56581 | 54 |
// Enable monitoring |
55767 | 55 |
_monitoring_support = new EpsilonMonitoringSupport(this); |
56 |
_last_counter_update = 0; |
|
55979 | 57 |
_last_heap_print = 0; |
58 |
||
56581 | 59 |
// Install barrier set |
60 |
BarrierSet::set_barrier_set(new EpsilonBarrierSet()); |
|
55767 | 61 |
|
56581 | 62 |
// All done, print out the configuration |
55767 | 63 |
if (init_byte_size != max_byte_size) { |
56580 | 64 |
log_info(gc)("Resizeable heap; starting at " SIZE_FORMAT "M, max: " SIZE_FORMAT "M, step: " SIZE_FORMAT "M", |
55767 | 65 |
init_byte_size / M, max_byte_size / M, EpsilonMinHeapExpand / M); |
66 |
} else { |
|
56580 | 67 |
log_info(gc)("Non-resizeable heap; start/max: " SIZE_FORMAT "M", init_byte_size / M); |
55767 | 68 |
} |
56581 | 69 |
|
55767 | 70 |
if (UseTLAB) { |
56577 | 71 |
log_info(gc)("Using TLAB allocation; max: " SIZE_FORMAT "K", _max_tlab_size * HeapWordSize / K); |
72 |
if (EpsilonElasticTLAB) { |
|
56580 | 73 |
log_info(gc)("Elastic TLABs enabled; elasticity: %.2fx", EpsilonTLABElasticity); |
56577 | 74 |
} |
75 |
if (EpsilonElasticTLABDecay) { |
|
56580 | 76 |
log_info(gc)("Elastic TLABs decay enabled; decay time: " SIZE_FORMAT "ms", EpsilonTLABDecayTime); |
56577 | 77 |
} |
55767 | 78 |
} else { |
79 |
log_info(gc)("Not using TLAB allocation"); |
|
80 |
} |
|
81 |
||
82 |
return JNI_OK; |
|
83 |
} |
|
84 |
||
55974 | 85 |
void EpsilonHeap::post_initialize() { |
86 |
CollectedHeap::post_initialize(); |
|
87 |
} |
|
88 |
||
89 |
void EpsilonHeap::initialize_serviceability() { |
|
55975 | 90 |
_pool = new EpsilonMemoryPool(this); |
91 |
_memory_manager.add_pool(_pool); |
|
55974 | 92 |
} |
93 |
||
94 |
GrowableArray<GCMemoryManager*> EpsilonHeap::memory_managers() { |
|
55975 | 95 |
GrowableArray<GCMemoryManager*> memory_managers(1); |
96 |
memory_managers.append(&_memory_manager); |
|
55974 | 97 |
return memory_managers; |
98 |
} |
|
99 |
||
100 |
GrowableArray<MemoryPool*> EpsilonHeap::memory_pools() { |
|
56492 | 101 |
GrowableArray<MemoryPool*> memory_pools(1); |
55975 | 102 |
memory_pools.append(_pool); |
55974 | 103 |
return memory_pools; |
104 |
} |
|
105 |
||
56352 | 106 |
size_t EpsilonHeap::unsafe_max_tlab_alloc(Thread* thr) const { |
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
107 |
// Return max allocatable TLAB size, and let allocation path figure out |
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
108 |
// the actual TLAB allocation size. |
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
109 |
return _max_tlab_size; |
55767 | 110 |
} |
111 |
||
55939 | 112 |
EpsilonHeap* EpsilonHeap::heap() { |
55767 | 113 |
CollectedHeap* heap = Universe::heap(); |
55939 | 114 |
assert(heap != NULL, "Uninitialized access to EpsilonHeap::heap()"); |
56492 | 115 |
assert(heap->kind() == CollectedHeap::Epsilon, "Not an Epsilon heap"); |
55939 | 116 |
return (EpsilonHeap*)heap; |
55767 | 117 |
} |
118 |
||
55939 | 119 |
HeapWord* EpsilonHeap::allocate_work(size_t size) { |
55767 | 120 |
HeapWord* res = _space->par_allocate(size); |
121 |
||
122 |
while (res == NULL) { |
|
123 |
// Allocation failed, attempt expansion, and retry: |
|
124 |
MutexLockerEx ml(Heap_lock); |
|
55980
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
125 |
|
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
126 |
size_t space_left = max_capacity() - capacity(); |
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
127 |
size_t want_space = MAX2(size, EpsilonMinHeapExpand); |
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
128 |
|
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
129 |
if (want_space < space_left) { |
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
130 |
// Enough space to expand in bulk: |
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
131 |
bool expand = _virtual_space.expand_by(want_space); |
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
132 |
assert(expand, "Should be able to expand"); |
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
133 |
} else if (size < space_left) { |
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
134 |
// No space to expand in bulk, and this allocation is still possible, |
56581 | 135 |
// take all the remaining space: |
55980
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
136 |
bool expand = _virtual_space.expand_by(space_left); |
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
137 |
assert(expand, "Should be able to expand"); |
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
138 |
} else { |
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
139 |
// No space left: |
55767 | 140 |
return NULL; |
141 |
} |
|
55980
67d289ae67f5
Make sure Epsilon is able to use the last bit of expanded heap
shade
parents:
55979
diff
changeset
|
142 |
|
55767 | 143 |
_space->set_end((HeapWord *) _virtual_space.high()); |
144 |
res = _space->par_allocate(size); |
|
145 |
} |
|
146 |
||
56581 | 147 |
// Allocation successful, update counters |
55767 | 148 |
size_t used = _space->used(); |
55979 | 149 |
if (used - _last_counter_update >= _step_counter_update) { |
55767 | 150 |
_last_counter_update = used; |
151 |
_monitoring_support->update_counters(); |
|
152 |
} |
|
55979 | 153 |
|
56581 | 154 |
// ...and print the occupancy line, if needed |
55979 | 155 |
if (used - _last_heap_print >= _step_heap_print) { |
156 |
log_info(gc)("Heap: " SIZE_FORMAT "M reserved, " SIZE_FORMAT "M committed, " SIZE_FORMAT "M used", |
|
157 |
max_capacity() / M, capacity() / M, used / M); |
|
158 |
_last_heap_print = used; |
|
159 |
} |
|
160 |
||
55767 | 161 |
return res; |
162 |
} |
|
163 |
||
56508 | 164 |
HeapWord* EpsilonHeap::allocate_new_tlab(size_t min_size, |
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
165 |
size_t requested_size, |
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
166 |
size_t* actual_size) { |
56577 | 167 |
Thread* thread = Thread::current(); |
168 |
||
169 |
// Defaults in case elastic paths are not taken |
|
170 |
bool fits = true; |
|
171 |
size_t size = requested_size; |
|
172 |
size_t ergo_tlab = requested_size; |
|
173 |
int64_t time = 0; |
|
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
174 |
|
56577 | 175 |
if (EpsilonElasticTLAB) { |
176 |
ergo_tlab = EpsilonThreadLocalData::ergo_tlab_size(thread); |
|
177 |
||
178 |
if (EpsilonElasticTLABDecay) { |
|
56581 | 179 |
int64_t last_time = EpsilonThreadLocalData::last_tlab_time(thread); |
56577 | 180 |
time = (int64_t) os::javaTimeNanos(); |
181 |
||
56581 | 182 |
assert(last_time <= time, "time should be monotonic"); |
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
183 |
|
56577 | 184 |
// If the thread had not allocated recently, retract the ergonomic size. |
185 |
// This conserves memory when the thread had initial burst of allocations, |
|
186 |
// and then started allocating only sporadically. |
|
56581 | 187 |
if (last_time != 0 && (time - last_time > _decay_time_ns)) { |
56577 | 188 |
ergo_tlab = 0; |
189 |
EpsilonThreadLocalData::set_ergo_tlab_size(thread, 0); |
|
190 |
} |
|
191 |
} |
|
192 |
||
193 |
// If we can fit the allocation under current TLAB size, do so. |
|
194 |
// Otherwise, we want to elastically increase the TLAB size. |
|
195 |
fits = (requested_size <= ergo_tlab); |
|
196 |
if (!fits) { |
|
197 |
size = (size_t) (ergo_tlab * EpsilonTLABElasticity); |
|
198 |
} |
|
199 |
} |
|
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
200 |
|
56581 | 201 |
// Always honor boundaries |
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
202 |
size = MAX2(min_size, MIN2(_max_tlab_size, size)); |
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
203 |
|
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
204 |
if (log_is_enabled(Trace, gc)) { |
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
205 |
ResourceMark rm; |
56577 | 206 |
log_trace(gc)("TLAB size for \"%s\" (Requested: " SIZE_FORMAT "K, Min: " SIZE_FORMAT |
207 |
"K, Max: " SIZE_FORMAT "K, Ergo: " SIZE_FORMAT "K) -> " SIZE_FORMAT "K", |
|
208 |
thread->name(), |
|
209 |
requested_size * HeapWordSize / K, |
|
210 |
min_size * HeapWordSize / K, |
|
211 |
_max_tlab_size * HeapWordSize / K, |
|
212 |
ergo_tlab * HeapWordSize / K, |
|
213 |
size * HeapWordSize / K); |
|
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
214 |
} |
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
215 |
|
56581 | 216 |
// All prepared, let's do it! |
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
217 |
HeapWord* res = allocate_work(size); |
56581 | 218 |
|
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
219 |
if (res != NULL) { |
56577 | 220 |
// Allocation successful |
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
221 |
*actual_size = size; |
56577 | 222 |
if (EpsilonElasticTLABDecay) { |
56581 | 223 |
EpsilonThreadLocalData::set_last_tlab_time(thread, time); |
56577 | 224 |
} |
225 |
if (EpsilonElasticTLAB && !fits) { |
|
226 |
// If we requested expansion, this is our new ergonomic TLAB size |
|
227 |
EpsilonThreadLocalData::set_ergo_tlab_size(thread, size); |
|
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
228 |
} |
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
229 |
} else { |
56577 | 230 |
// Allocation failed, reset ergonomics to try and fit smaller TLABs |
231 |
if (EpsilonElasticTLAB) { |
|
232 |
EpsilonThreadLocalData::set_ergo_tlab_size(thread, 0); |
|
233 |
} |
|
56510
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
234 |
} |
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
235 |
|
54c1aa06c1d8
Epsilon should use Elastic TLABs facility to control sizes
shade
parents:
56508
diff
changeset
|
236 |
return res; |
55767 | 237 |
} |
238 |
||
55939 | 239 |
HeapWord* EpsilonHeap::mem_allocate(size_t size, bool *gc_overhead_limit_was_exceeded) { |
55767 | 240 |
*gc_overhead_limit_was_exceeded = false; |
241 |
return allocate_work(size); |
|
242 |
} |
|
243 |
||
55939 | 244 |
void EpsilonHeap::collect(GCCause::Cause cause) { |
56353 | 245 |
log_info(gc)("GC request for \"%s\" is ignored", GCCause::to_string(cause)); |
55767 | 246 |
_monitoring_support->update_counters(); |
247 |
} |
|
248 |
||
55939 | 249 |
void EpsilonHeap::do_full_collection(bool clear_all_soft_refs) { |
56353 | 250 |
log_info(gc)("Full GC request for \"%s\" is ignored", GCCause::to_string(gc_cause())); |
55767 | 251 |
_monitoring_support->update_counters(); |
252 |
} |
|
253 |
||
55939 | 254 |
void EpsilonHeap::safe_object_iterate(ObjectClosure *cl) { |
55767 | 255 |
_space->safe_object_iterate(cl); |
256 |
} |
|
257 |
||
55939 | 258 |
void EpsilonHeap::print_on(outputStream *st) const { |
55767 | 259 |
st->print_cr("Epsilon Heap"); |
260 |
||
261 |
// Cast away constness: |
|
262 |
((VirtualSpace)_virtual_space).print_on(st); |
|
263 |
||
264 |
st->print_cr("Allocation space:"); |
|
265 |
_space->print_on(st); |
|
266 |
} |
|
267 |
||
55939 | 268 |
void EpsilonHeap::print_tracing_info() const { |
55767 | 269 |
Log(gc) log; |
270 |
size_t allocated_kb = used() / K; |
|
271 |
log.info("Total allocated: " SIZE_FORMAT " KB", |
|
272 |
allocated_kb); |
|
273 |
log.info("Average allocation rate: " SIZE_FORMAT " KB/sec", |
|
55976 | 274 |
(size_t)(allocated_kb * NANOSECS_PER_SEC / os::elapsed_counter())); |
55767 | 275 |
} |