jdk-sandbox: comparison src/hotspot/share/gc/epsilon/epsilonHeap.cpp

equal deleted inserted replaced

-:b6c934c3fda2
+:d6ace215b52c
 #include "memory/allocation.inline.hpp"
 #include "memory/resourceArea.hpp"
 jint EpsilonHeap::initialize() {
 size_t init_byte_size = _policy->initial_heap_byte_size();
-size_t max_byte_size = _policy->max_heap_byte_size();
+size_t max_byte_size  = _policy->max_heap_byte_size();
-size_t align = _policy->heap_alignment();
+// Initialize backing storage
-ReservedSpace heap_rs = Universe::reserve_heap(max_byte_size,  align);
+ReservedSpace heap_rs = Universe::reserve_heap(max_byte_size, _policy->heap_alignment());
 _virtual_space.initialize(heap_rs, init_byte_size);
-MemRegion committed_region((HeapWord*)_virtual_space.low(), (HeapWord*)_virtual_space.high());
+MemRegion committed_region((HeapWord*)_virtual_space.low(),          (HeapWord*)_virtual_space.high());
-MemRegion reserved_region((HeapWord*)_virtual_space.low_boundary(), (HeapWord*)_virtual_space.high_boundary());
+MemRegion  reserved_region((HeapWord*)_virtual_space.low_boundary(), (HeapWord*)_virtual_space.high_boundary());
 initialize_reserved_region(reserved_region.start(), reserved_region.end());
 _space = new ContiguousSpace();
-_space->initialize(committed_region, true, true);
+_space->initialize(committed_region, /* clear_space = */ true, /* mangle_space */ = true);
-BarrierSet::set_barrier_set(new EpsilonBarrierSet());
+// Precompute hot fields
 _max_tlab_size = MIN2(CollectedHeap::max_tlab_size(), EpsilonMaxTLABSize / HeapWordSize);
+_step_counter_update = MIN2<size_t>(max_byte_size / 16, EpsilonUpdateCountersStep);
+_step_heap_print = (EpsilonPrintHeapStep == 0) ? SIZE_MAX : (max_byte_size / EpsilonPrintHeapStep);
+_decay_time_ns = (int64_t) EpsilonTLABDecayTime * 1000 * 1000;
+// Enable monitoring
 _monitoring_support = new EpsilonMonitoringSupport(this);
 _last_counter_update = 0;
 _last_heap_print = 0;
-_step_counter_update = MIN2<size_t>(max_byte_size / 16, EpsilonUpdateCountersStep);
+// Install barrier set
-_step_heap_print = (EpsilonPrintHeapStep == 0) ? SIZE_MAX : (max_byte_size / EpsilonPrintHeapStep);
+BarrierSet::set_barrier_set(new EpsilonBarrierSet());
-_decay_time_ns = (int64_t) EpsilonTLABDecayTime * 1000 * 1000;
+// All done, print out the configuration
 if (init_byte_size != max_byte_size) {
 log_info(gc)("Resizeable heap; starting at " SIZE_FORMAT "M, max: " SIZE_FORMAT "M, step: " SIZE_FORMAT "M",
 init_byte_size / M, max_byte_size / M, EpsilonMinHeapExpand / M);
 } else {
 log_info(gc)("Non-resizeable heap; start/max: " SIZE_FORMAT "M", init_byte_size / M);
 }
 if (UseTLAB) {
 log_info(gc)("Using TLAB allocation; max: " SIZE_FORMAT "K", _max_tlab_size * HeapWordSize / K);
 if (EpsilonElasticTLAB) {
 log_info(gc)("Elastic TLABs enabled; elasticity: %.2fx", EpsilonTLABElasticity);
 }
 // Enough space to expand in bulk:
 bool expand = _virtual_space.expand_by(want_space);
 assert(expand, "Should be able to expand");
 } else if (size < space_left) {
 // No space to expand in bulk, and this allocation is still possible,
-// take all the space left:
+// take all the remaining space:
 bool expand = _virtual_space.expand_by(space_left);
 assert(expand, "Should be able to expand");
 } else {
 // No space left:
 return NULL;
 _space->set_end((HeapWord *) _virtual_space.high());
 res = _space->par_allocate(size);
 }
+// Allocation successful, update counters
 size_t used = _space->used();
 if (used - _last_counter_update >= _step_counter_update) {
 _last_counter_update = used;
 _monitoring_support->update_counters();
 }
+// ...and print the occupancy line, if needed
 if (used - _last_heap_print >= _step_heap_print) {
 log_info(gc)("Heap: " SIZE_FORMAT "M reserved, " SIZE_FORMAT "M committed, " SIZE_FORMAT "M used",
 max_capacity() / M, capacity() / M, used / M);
 _last_heap_print = used;
 }
 if (EpsilonElasticTLAB) {
 ergo_tlab = EpsilonThreadLocalData::ergo_tlab_size(thread);
 if (EpsilonElasticTLABDecay) {
-int64_t last_alloc = EpsilonThreadLocalData::last_alloc_time(thread);
+int64_t last_time = EpsilonThreadLocalData::last_tlab_time(thread);
 time = (int64_t) os::javaTimeNanos();
-assert(last_alloc <= time, "time should be monotonic");
+assert(last_time <= time, "time should be monotonic");
 // If the thread had not allocated recently, retract the ergonomic size.
 // This conserves memory when the thread had initial burst of allocations,
 // and then started allocating only sporadically.
-if (last_alloc != 0 && (time - last_alloc > _decay_time_ns)) {
+if (last_time != 0 && (time - last_time > _decay_time_ns)) {
 ergo_tlab = 0;
 EpsilonThreadLocalData::set_ergo_tlab_size(thread, 0);
 }
 }
 if (!fits) {
 size = (size_t) (ergo_tlab * EpsilonTLABElasticity);
 }
 }
-// Honor boundaries
+// Always honor boundaries
 size = MAX2(min_size, MIN2(_max_tlab_size, size));
 if (log_is_enabled(Trace, gc)) {
 ResourceMark rm;
 log_trace(gc)("TLAB size for \"%s\" (Requested: " SIZE_FORMAT "K, Min: " SIZE_FORMAT
 _max_tlab_size * HeapWordSize / K,
 ergo_tlab * HeapWordSize / K,
 size * HeapWordSize / K);
 }
+// All prepared, let's do it!
 HeapWord* res = allocate_work(size);
 if (res != NULL) {
 // Allocation successful
 *actual_size = size;
 if (EpsilonElasticTLABDecay) {
-EpsilonThreadLocalData::set_last_alloc_time(thread, time);
+EpsilonThreadLocalData::set_last_tlab_time(thread, time);
 }
 if (EpsilonElasticTLAB && !fits) {
 // If we requested expansion, this is our new ergonomic TLAB size
 EpsilonThreadLocalData::set_ergo_tlab_size(thread, size);
 }

branch	epsilon-gc-branch
changeset 56581	d6ace215b52c
parent 56580	b6c934c3fda2
child 56582	c75a617df2f8