infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-03-28 16:50:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

8380523: Refactor TLAB slow allocation naming

Browse Source 
Reviewed-by: stefank, jsikstro
This commit is contained in:
Albert Mingkun Yang 2026-03-25 16:32:44 +00:00
parent 02972a5856
commit 331c754017
5 changed files with 116 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
src/hotspot/share/gc/shared/threadLocalAllocBuffer.cpp
View File

@ -37,7 +37,7 @@
#include "utilities/copy.hpp"
size_t ThreadLocalAllocBuffer::_max_size = 0;
unsigned int ThreadLocalAllocBuffer::_target_refills = 0;
unsigned int ThreadLocalAllocBuffer::_target_num_refills = 0;
ThreadLocalAllocBuffer::ThreadLocalAllocBuffer() :
_start(nullptr),
@ -48,10 +48,10 @@ ThreadLocalAllocBuffer::ThreadLocalAllocBuffer() :
_desired_size(0),
_refill_waste_limit(0),
_allocated_before_last_gc(0),
_number_of_refills(0),
_num_refills(0),
_refill_waste(0),
_gc_waste(0),
_slow_allocations(0),
_num_slow_allocations(0),
_allocated_size(0),
_allocation_fraction(TLABAllocationWeight) {
@ -81,7 +81,7 @@ void ThreadLocalAllocBuffer::accumulate_and_reset_statistics(ThreadLocalAllocSta
print_stats("gc");
if (_number_of_refills > 0) {
if (_num_refills > 0) {
// Update allocation history if a reasonable amount of eden was allocated.
bool update_allocation_history = used > 0.5 * capacity;
@ -98,16 +98,16 @@ void ThreadLocalAllocBuffer::accumulate_and_reset_statistics(ThreadLocalAllocSta
_allocation_fraction.sample(alloc_frac);
}
stats->update_fast_allocations(_number_of_refills,
stats->update_fast_allocations(_num_refills,
_allocated_size,
_gc_waste,
_refill_waste);
} else {
assert(_number_of_refills == 0 && _refill_waste == 0 && _gc_waste == 0,
assert(_num_refills == 0 && _refill_waste == 0 && _gc_waste == 0,
"tlab stats == 0");
}
stats->update_slow_allocations(_slow_allocations);
stats->update_num_slow_allocations(_num_slow_allocations);
reset_statistics();
}
@ -147,7 +147,7 @@ void ThreadLocalAllocBuffer::resize() {
assert(ResizeTLAB, "Should not call this otherwise");
size_t alloc = (size_t)(_allocation_fraction.average() *
(Universe::heap()->tlab_capacity() / HeapWordSize));
size_t new_size = alloc / _target_refills;
size_t new_size = alloc / _target_num_refills;
new_size = clamp(new_size, min_size(), max_size());
@ -156,24 +156,24 @@ void ThreadLocalAllocBuffer::resize() {
log_trace(gc, tlab)("TLAB new size: thread: " PTR_FORMAT " [id: %2d]"
" refills %d alloc: %8.6f desired_size: %zu -> %zu",
p2i(thread()), thread()->osthread()->thread_id(),
_target_refills, _allocation_fraction.average(), desired_size(), aligned_new_size);
_target_num_refills, _allocation_fraction.average(), desired_size(), aligned_new_size);
set_desired_size(aligned_new_size);
set_refill_waste_limit(initial_refill_waste_limit());
}
void ThreadLocalAllocBuffer::reset_statistics() {
_number_of_refills = 0;
_refill_waste = 0;
_gc_waste = 0;
_slow_allocations = 0;
_allocated_size = 0;
_num_refills = 0;
_refill_waste = 0;
_gc_waste = 0;
_num_slow_allocations = 0;
_allocated_size = 0;
}
void ThreadLocalAllocBuffer::fill(HeapWord* start,
HeapWord* top,
size_t new_size) {
_number_of_refills++;
_num_refills++;
_allocated_size += new_size;
print_stats("fill");
assert(top <= start + new_size - alignment_reserve(), "size too small");
@ -205,7 +205,7 @@ void ThreadLocalAllocBuffer::initialize() {
size_t capacity = Universe::heap()->tlab_capacity() / HeapWordSize;
if (capacity > 0) {
// Keep alloc_frac as float and not double to avoid the double to float conversion
float alloc_frac = desired_size() * target_refills() / (float)capacity;
float alloc_frac = desired_size() * target_num_refills() / (float)capacity;
_allocation_fraction.sample(alloc_frac);
}
@ -219,10 +219,10 @@ void ThreadLocalAllocBuffer::startup_initialization() {
// Assuming each thread's active tlab is, on average,
// 1/2 full at a GC
_target_refills = 100 / (2 * TLABWasteTargetPercent);
// We need to set initial target refills to 2 to avoid a GC which causes VM
_target_num_refills = 100 / (2 * TLABWasteTargetPercent);
// We need to set the initial target number of refills to 2 to avoid a GC which causes VM
// abort during VM initialization.
_target_refills = MAX2(_target_refills, 2U);
_target_num_refills = MAX2(_target_num_refills, 2U);
// During jvm startup, the main thread is initialized
// before the heap is initialized. So reinitialize it now.
@ -240,10 +240,10 @@ size_t ThreadLocalAllocBuffer::initial_desired_size() {
init_sz = TLABSize / HeapWordSize;
} else {
// Initial size is a function of the average number of allocating threads.
unsigned int nof_threads = ThreadLocalAllocStats::allocating_threads_avg();
unsigned int num_threads = ThreadLocalAllocStats::num_allocating_threads_avg();
init_sz = (Universe::heap()->tlab_capacity() / HeapWordSize) /
(nof_threads * target_refills());
(num_threads * target_num_refills());
init_sz = align_object_size(init_sz);
}
// We can't use clamp() between min_size() and max_size() here because some
@ -271,10 +271,10 @@ void ThreadLocalAllocBuffer::print_stats(const char* tag) {
" slow: %dB",
tag, p2i(thrd), thrd->osthread()->thread_id(),
_desired_size / (K / HeapWordSize),
_slow_allocations, _refill_waste_limit * HeapWordSize,
_num_slow_allocations, _refill_waste_limit * HeapWordSize,
_allocation_fraction.average(),
_allocation_fraction.average() * tlab_used / K,
_number_of_refills, waste_percent,
_num_refills, waste_percent,
_gc_waste * HeapWordSize,
_refill_waste * HeapWordSize);
}
@ -299,17 +299,17 @@ HeapWord* ThreadLocalAllocBuffer::hard_end() {
return _allocation_end + alignment_reserve();
}
PerfVariable* ThreadLocalAllocStats::_perf_allocating_threads;
PerfVariable* ThreadLocalAllocStats::_perf_total_refills;
PerfVariable* ThreadLocalAllocStats::_perf_max_refills;
PerfVariable* ThreadLocalAllocStats::_perf_num_allocating_threads;
PerfVariable* ThreadLocalAllocStats::_perf_total_num_refills;
PerfVariable* ThreadLocalAllocStats::_perf_max_num_refills;
PerfVariable* ThreadLocalAllocStats::_perf_total_allocated_size;
PerfVariable* ThreadLocalAllocStats::_perf_total_gc_waste;
PerfVariable* ThreadLocalAllocStats::_perf_max_gc_waste;
PerfVariable* ThreadLocalAllocStats::_perf_total_refill_waste;
PerfVariable* ThreadLocalAllocStats::_perf_max_refill_waste;
PerfVariable* ThreadLocalAllocStats::_perf_total_slow_allocations;
PerfVariable* ThreadLocalAllocStats::_perf_max_slow_allocations;
AdaptiveWeightedAverage ThreadLocalAllocStats::_allocating_threads_avg(0);
PerfVariable* ThreadLocalAllocStats::_perf_total_num_slow_allocations;
PerfVariable* ThreadLocalAllocStats::_perf_max_num_slow_allocations;
AdaptiveWeightedAverage ThreadLocalAllocStats::_num_allocating_threads_avg(0);
static PerfVariable* create_perf_variable(const char* name, PerfData::Units unit, TRAPS) {
ResourceMark rm;
@ -317,47 +317,47 @@ static PerfVariable* create_perf_variable(const char* name, PerfData::Units unit
}
void ThreadLocalAllocStats::initialize() {
_allocating_threads_avg = AdaptiveWeightedAverage(TLABAllocationWeight);
_allocating_threads_avg.sample(1); // One allocating thread at startup
_num_allocating_threads_avg = AdaptiveWeightedAverage(TLABAllocationWeight);
_num_allocating_threads_avg.sample(1); // One allocating thread at startup
if (UsePerfData) {
EXCEPTION_MARK;
_perf_allocating_threads = create_perf_variable("allocThreads", PerfData::U_None, CHECK);
_perf_total_refills = create_perf_variable("fills", PerfData::U_None, CHECK);
_perf_max_refills = create_perf_variable("maxFills", PerfData::U_None, CHECK);
_perf_total_allocated_size = create_perf_variable("alloc", PerfData::U_Bytes, CHECK);
_perf_total_gc_waste = create_perf_variable("gcWaste", PerfData::U_Bytes, CHECK);
_perf_max_gc_waste = create_perf_variable("maxGcWaste", PerfData::U_Bytes, CHECK);
_perf_total_refill_waste = create_perf_variable("refillWaste", PerfData::U_Bytes, CHECK);
_perf_max_refill_waste = create_perf_variable("maxRefillWaste", PerfData::U_Bytes, CHECK);
_perf_total_slow_allocations = create_perf_variable("slowAlloc", PerfData::U_None, CHECK);
_perf_max_slow_allocations = create_perf_variable("maxSlowAlloc", PerfData::U_None, CHECK);
_perf_num_allocating_threads = create_perf_variable("allocThreads", PerfData::U_None, CHECK);
_perf_total_num_refills = create_perf_variable("fills", PerfData::U_None, CHECK);
_perf_max_num_refills = create_perf_variable("maxFills", PerfData::U_None, CHECK);
_perf_total_allocated_size = create_perf_variable("alloc", PerfData::U_Bytes, CHECK);
_perf_total_gc_waste = create_perf_variable("gcWaste", PerfData::U_Bytes, CHECK);
_perf_max_gc_waste = create_perf_variable("maxGcWaste", PerfData::U_Bytes, CHECK);
_perf_total_refill_waste = create_perf_variable("refillWaste", PerfData::U_Bytes, CHECK);
_perf_max_refill_waste = create_perf_variable("maxRefillWaste", PerfData::U_Bytes, CHECK);
_perf_total_num_slow_allocations = create_perf_variable("slowAlloc", PerfData::U_None, CHECK);
_perf_max_num_slow_allocations = create_perf_variable("maxSlowAlloc", PerfData::U_None, CHECK);
}
}
ThreadLocalAllocStats::ThreadLocalAllocStats() :
_allocating_threads(0),
_total_refills(0),
_max_refills(0),
_num_allocating_threads(0),
_total_num_refills(0),
_max_num_refills(0),
_total_allocated_size(0),
_total_gc_waste(0),
_max_gc_waste(0),
_total_refill_waste(0),
_max_refill_waste(0),
_total_slow_allocations(0),
_max_slow_allocations(0) {}
_total_num_slow_allocations(0),
_max_num_slow_allocations(0) {}
unsigned int ThreadLocalAllocStats::allocating_threads_avg() {
return MAX2((unsigned int)(_allocating_threads_avg.average() + 0.5), 1U);
unsigned int ThreadLocalAllocStats::num_allocating_threads_avg() {
return MAX2((unsigned int)(_num_allocating_threads_avg.average() + 0.5), 1U);
}
void ThreadLocalAllocStats::update_fast_allocations(unsigned int refills,
void ThreadLocalAllocStats::update_fast_allocations(unsigned int num_refills,
size_t allocated_size,
size_t gc_waste,
size_t refill_waste) {
_allocating_threads += 1;
_total_refills += refills;
_max_refills = MAX2(_max_refills, refills);
_num_allocating_threads += 1;
_total_num_refills += num_refills;
_max_num_refills = MAX2(_max_num_refills, num_refills);
_total_allocated_size += allocated_size;
_total_gc_waste += gc_waste;
_max_gc_waste = MAX2(_max_gc_waste, gc_waste);
@ -365,35 +365,35 @@ void ThreadLocalAllocStats::update_fast_allocations(unsigned int refills,
_max_refill_waste = MAX2(_max_refill_waste, refill_waste);
}
void ThreadLocalAllocStats::update_slow_allocations(unsigned int allocations) {
_total_slow_allocations += allocations;
_max_slow_allocations = MAX2(_max_slow_allocations, allocations);
void ThreadLocalAllocStats::update_num_slow_allocations(unsigned int num_slow_allocations) {
_total_num_slow_allocations += num_slow_allocations;
_max_num_slow_allocations = MAX2(_max_num_slow_allocations, num_slow_allocations);
}
void ThreadLocalAllocStats::update(const ThreadLocalAllocStats& other) {
_allocating_threads += other._allocating_threads;
_total_refills += other._total_refills;
_max_refills = MAX2(_max_refills, other._max_refills);
_total_allocated_size += other._total_allocated_size;
_total_gc_waste += other._total_gc_waste;
_max_gc_waste = MAX2(_max_gc_waste, other._max_gc_waste);
_total_refill_waste += other._total_refill_waste;
_max_refill_waste = MAX2(_max_refill_waste, other._max_refill_waste);
_total_slow_allocations += other._total_slow_allocations;
_max_slow_allocations = MAX2(_max_slow_allocations, other._max_slow_allocations);
_num_allocating_threads += other._num_allocating_threads;
_total_num_refills += other._total_num_refills;
_max_num_refills = MAX2(_max_num_refills, other._max_num_refills);
_total_allocated_size += other._total_allocated_size;
_total_gc_waste += other._total_gc_waste;
_max_gc_waste = MAX2(_max_gc_waste, other._max_gc_waste);
_total_refill_waste += other._total_refill_waste;
_max_refill_waste = MAX2(_max_refill_waste, other._max_refill_waste);
_total_num_slow_allocations += other._total_num_slow_allocations;
_max_num_slow_allocations = MAX2(_max_num_slow_allocations, other._max_num_slow_allocations);
}
void ThreadLocalAllocStats::reset() {
_allocating_threads = 0;
_total_refills = 0;
_max_refills = 0;
_total_allocated_size = 0;
_total_gc_waste = 0;
_max_gc_waste = 0;
_total_refill_waste = 0;
_max_refill_waste = 0;
_total_slow_allocations = 0;
_max_slow_allocations = 0;
_num_allocating_threads = 0;
_total_num_refills = 0;
_max_num_refills = 0;
_total_allocated_size = 0;
_total_gc_waste = 0;
_max_gc_waste = 0;
_total_refill_waste = 0;
_max_refill_waste = 0;
_total_num_slow_allocations = 0;
_max_num_slow_allocations = 0;
}
void ThreadLocalAllocStats::publish() {
@ -401,7 +401,7 @@ void ThreadLocalAllocStats::publish() {
return;
}
_allocating_threads_avg.sample(_allocating_threads);
_num_allocating_threads_avg.sample(_num_allocating_threads);
const size_t waste = _total_gc_waste + _total_refill_waste;
const double waste_percent = percent_of(waste, _total_allocated_size);
@ -409,22 +409,22 @@ void ThreadLocalAllocStats::publish() {
" slow allocs: %d max %d waste: %4.1f%%"
" gc: %zuB max: %zuB"
" slow: %zuB max: %zuB",
_allocating_threads, _total_refills, _max_refills,
_total_slow_allocations, _max_slow_allocations, waste_percent,
_num_allocating_threads, _total_num_refills, _max_num_refills,
_total_num_slow_allocations, _max_num_slow_allocations, waste_percent,
_total_gc_waste * HeapWordSize, _max_gc_waste * HeapWordSize,
_total_refill_waste * HeapWordSize, _max_refill_waste * HeapWordSize);
if (UsePerfData) {
_perf_allocating_threads ->set_value(_allocating_threads);
_perf_total_refills ->set_value(_total_refills);
_perf_max_refills ->set_value(_max_refills);
_perf_total_allocated_size ->set_value(_total_allocated_size);
_perf_total_gc_waste ->set_value(_total_gc_waste);
_perf_max_gc_waste ->set_value(_max_gc_waste);
_perf_total_refill_waste ->set_value(_total_refill_waste);
_perf_max_refill_waste ->set_value(_max_refill_waste);
_perf_total_slow_allocations ->set_value(_total_slow_allocations);
_perf_max_slow_allocations ->set_value(_max_slow_allocations);
_perf_num_allocating_threads ->set_value(_num_allocating_threads);
_perf_total_num_refills ->set_value(_total_num_refills);
_perf_max_num_refills ->set_value(_max_num_refills);
_perf_total_allocated_size ->set_value(_total_allocated_size);
_perf_total_gc_waste ->set_value(_total_gc_waste);
_perf_max_gc_waste ->set_value(_max_gc_waste);
_perf_total_refill_waste ->set_value(_total_refill_waste);
_perf_max_refill_waste ->set_value(_max_refill_waste);
_perf_total_num_slow_allocations ->set_value(_total_num_slow_allocations);
_perf_max_num_slow_allocations ->set_value(_max_num_slow_allocations);
}
}

44
src/hotspot/share/gc/shared/threadLocalAllocBuffer.hpp
View File

@ -56,13 +56,13 @@ private:
size_t _refill_waste_limit; // hold onto tlab if free() is larger than this
uint64_t _allocated_before_last_gc; // total bytes allocated up until the last gc
static size_t _max_size; // maximum size of any TLAB
static unsigned _target_refills; // expected number of refills between GCs
static size_t _max_size; // maximum size of any TLAB
static unsigned _target_num_refills; // expected number of refills between GCs
unsigned _number_of_refills;
unsigned _num_refills;
unsigned _refill_waste;
unsigned _gc_waste;
unsigned _slow_allocations;
unsigned _num_slow_allocations;
size_t _allocated_size;
AdaptiveWeightedAverage _allocation_fraction; // fraction of eden allocated in tlabs
@ -79,7 +79,7 @@ private:
size_t initial_refill_waste_limit();
static int target_refills() { return _target_refills; }
static int target_num_refills() { return _target_num_refills; }
size_t initial_desired_size();
size_t remaining();
@ -98,9 +98,9 @@ private:
// statistics
int number_of_refills() const { return _number_of_refills; }
int gc_waste() const { return _gc_waste; }
int slow_allocations() const { return _slow_allocations; }
int num_refills() const { return _num_refills; }
int gc_waste() const { return _gc_waste; }
int num_slow_allocations() const { return _num_slow_allocations; }
public:
ThreadLocalAllocBuffer();
@ -179,41 +179,41 @@ public:
class ThreadLocalAllocStats : public StackObj {
private:
static PerfVariable* _perf_allocating_threads;
static PerfVariable* _perf_total_refills;
static PerfVariable* _perf_max_refills;
static PerfVariable* _perf_num_allocating_threads;
static PerfVariable* _perf_total_num_refills;
static PerfVariable* _perf_max_num_refills;
static PerfVariable* _perf_total_allocated_size;
static PerfVariable* _perf_total_gc_waste;
static PerfVariable* _perf_max_gc_waste;
static PerfVariable* _perf_total_refill_waste;
static PerfVariable* _perf_max_refill_waste;
static PerfVariable* _perf_total_slow_allocations;
static PerfVariable* _perf_max_slow_allocations;
static PerfVariable* _perf_total_num_slow_allocations;
static PerfVariable* _perf_max_num_slow_allocations;
static AdaptiveWeightedAverage _allocating_threads_avg;
static AdaptiveWeightedAverage _num_allocating_threads_avg;
unsigned int _allocating_threads;
unsigned int _total_refills;
unsigned int _max_refills;
unsigned int _num_allocating_threads;
unsigned int _total_num_refills;
unsigned int _max_num_refills;
size_t _total_allocated_size;
size_t _total_gc_waste;
size_t _max_gc_waste;
size_t _total_refill_waste;
size_t _max_refill_waste;
unsigned int _total_slow_allocations;
unsigned int _max_slow_allocations;
unsigned int _total_num_slow_allocations;
unsigned int _max_num_slow_allocations;
public:
static void initialize();
static unsigned int allocating_threads_avg();
static unsigned int num_allocating_threads_avg();
ThreadLocalAllocStats();
void update_fast_allocations(unsigned int refills,
void update_fast_allocations(unsigned int num_refills,
size_t allocated_size,
size_t gc_waste,
size_t refill_waste);
void update_slow_allocations(unsigned int allocations);
void update_num_slow_allocations(unsigned int num_slow_allocations);
void update(const ThreadLocalAllocStats& other);
void reset();

2
src/hotspot/share/gc/shared/threadLocalAllocBuffer.inline.hpp
View File

@ -82,7 +82,7 @@ void ThreadLocalAllocBuffer::record_slow_allocation(size_t obj_size) {
set_refill_waste_limit(refill_waste_limit() + refill_waste_limit_increment());
_slow_allocations++;
_num_slow_allocations++;
log_develop_trace(gc, tlab)("TLAB: %s thread: " PTR_FORMAT " [id: %2d]"
" obj: %zu"

4
src/hotspot/share/jvmci/vmStructs_jvmci.cpp
View File

@ -450,8 +450,8 @@
nonstatic_field(ThreadLocalAllocBuffer, _pf_top, HeapWord*) \
nonstatic_field(ThreadLocalAllocBuffer, _desired_size, size_t) \
nonstatic_field(ThreadLocalAllocBuffer, _refill_waste_limit, size_t) \
nonstatic_field(ThreadLocalAllocBuffer, _number_of_refills, unsigned) \
nonstatic_field(ThreadLocalAllocBuffer, _slow_allocations, unsigned) \
nonstatic_field(ThreadLocalAllocBuffer, _num_refills, unsigned) \
nonstatic_field(ThreadLocalAllocBuffer, _num_slow_allocations, unsigned) \
\
nonstatic_field(SafepointMechanism::ThreadData, _polling_word, volatile uintptr_t) \
nonstatic_field(SafepointMechanism::ThreadData, _polling_page, volatile uintptr_t) \

7
src/hotspot/share/runtime/vmStructs.cpp
View File

@ -335,11 +335,11 @@
nonstatic_field(ThreadLocalAllocBuffer, _pf_top, HeapWord*) \
nonstatic_field(ThreadLocalAllocBuffer, _desired_size, size_t) \
nonstatic_field(ThreadLocalAllocBuffer, _refill_waste_limit, size_t) \
static_field(ThreadLocalAllocBuffer, _target_refills, unsigned) \
nonstatic_field(ThreadLocalAllocBuffer, _number_of_refills, unsigned) \
static_field(ThreadLocalAllocBuffer, _target_num_refills, unsigned) \
nonstatic_field(ThreadLocalAllocBuffer, _num_refills, unsigned) \
nonstatic_field(ThreadLocalAllocBuffer, _refill_waste, unsigned) \
nonstatic_field(ThreadLocalAllocBuffer, _gc_waste, unsigned) \
nonstatic_field(ThreadLocalAllocBuffer, _slow_allocations, unsigned) \
nonstatic_field(ThreadLocalAllocBuffer, _num_slow_allocations, unsigned) \
nonstatic_field(VirtualSpace, _low_boundary, char*) \
nonstatic_field(VirtualSpace, _high_boundary, char*) \
nonstatic_field(VirtualSpace, _low, char*) \
@ -2142,4 +2142,3 @@ void vmStructs_init() {
VMStructs::init();
}
#endif // ASSERT