--- old/src/hotspot/share/gc/g1/g1CollectedHeap.cpp 2018-05-02 11:21:13.972754981 +0200 +++ new/src/hotspot/share/gc/g1/g1CollectedHeap.cpp 2018-05-02 11:21:13.620741052 +0200 @@ -384,13 +384,13 @@ return result; } -HeapWord* G1CollectedHeap::allocate_new_tlab(size_t min_word_size, - size_t desired_word_size, - size_t* actual_word_size) { +HeapWord* G1CollectedHeap::allocate_new_tlab(size_t min_size, + size_t requested_size, + size_t* actual_size) { assert_heap_not_locked_and_not_at_safepoint(); - assert(!is_humongous(desired_word_size), "we do not allow humongous TLABs"); + assert(!is_humongous(requested_size), "we do not allow humongous TLABs"); - return attempt_allocation(min_word_size, desired_word_size, actual_word_size); + return attempt_allocation(min_size, requested_size, actual_size); } HeapWord* --- old/src/hotspot/share/gc/g1/g1CollectedHeap.hpp 2018-05-02 11:21:14.976794709 +0200 +++ new/src/hotspot/share/gc/g1/g1CollectedHeap.hpp 2018-05-02 11:21:14.616780464 +0200 @@ -420,9 +420,9 @@ // humongous allocation requests should go to mem_allocate() which // will satisfy them with a special path. - virtual HeapWord* allocate_new_tlab(size_t min_word_size, - size_t desired_word_size, - size_t* actual_word_size); + virtual HeapWord* allocate_new_tlab(size_t min_size, + size_t requested_size, + size_t* actual_size); virtual HeapWord* mem_allocate(size_t word_size, bool* gc_overhead_limit_was_exceeded); --- old/src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp 2018-05-02 11:21:15.912831746 +0200 +++ new/src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp 2018-05-02 11:21:15.564817976 +0200 @@ -478,10 +478,10 @@ return young_gen()->eden_space()->unsafe_max_tlab_alloc(thr); } -HeapWord* ParallelScavengeHeap::allocate_new_tlab(size_t minimal_size, size_t size, size_t* actual_size) { - HeapWord* result = young_gen()->allocate(size); +HeapWord* ParallelScavengeHeap::allocate_new_tlab(size_t min_size, size_t requested_size, size_t* actual_size) { + HeapWord* result = young_gen()->allocate(requested_size); if (result != NULL) { - *actual_size = size; + *actual_size = requested_size; } return result; --- old/src/hotspot/share/gc/parallel/parallelScavengeHeap.hpp 2018-05-02 11:21:16.860869258 +0200 +++ new/src/hotspot/share/gc/parallel/parallelScavengeHeap.hpp 2018-05-02 11:21:16.512855488 +0200 @@ -85,7 +85,7 @@ protected: static inline size_t total_invocations(); - HeapWord* allocate_new_tlab(size_t minimal_size, size_t size, size_t* actual_size); + HeapWord* allocate_new_tlab(size_t min_size, size_t requested_size, size_t* actual_size); inline bool should_alloc_in_eden(size_t size) const; inline void death_march_check(HeapWord* const result, size_t size); --- old/src/hotspot/share/gc/shared/collectedHeap.cpp 2018-05-02 11:21:17.792906137 +0200 +++ new/src/hotspot/share/gc/shared/collectedHeap.cpp 2018-05-02 11:21:17.424891576 +0200 @@ -387,15 +387,15 @@ // Allocate a new TLAB requesting new_tlab_size. Any size // between minimal and new_tlab_size is accepted. size_t actual_tlab_size = 0; - size_t minimal_tlab_size = MAX2(ThreadLocalAllocBuffer::compute_min_size(size), MinTLABSize); - HeapWord* obj = Universe::heap()->allocate_new_tlab(minimal_tlab_size, new_tlab_size, &actual_tlab_size); + size_t min_tlab_size = ThreadLocalAllocBuffer::compute_min_size(size); + HeapWord* obj = Universe::heap()->allocate_new_tlab(min_tlab_size, new_tlab_size, &actual_tlab_size); if (obj == NULL) { assert(actual_tlab_size == 0, "Allocation failed, but actual size was updated. min: " SIZE_FORMAT ", desired: " SIZE_FORMAT ", actual: " SIZE_FORMAT, - minimal_tlab_size, new_tlab_size, actual_tlab_size); + min_tlab_size, new_tlab_size, actual_tlab_size); return NULL; } assert(actual_tlab_size != 0, "Allocation succeeded but actual size not updated. obj at: " PTR_FORMAT " min: " SIZE_FORMAT ", desired: " SIZE_FORMAT, - p2i(obj), minimal_tlab_size, new_tlab_size); + p2i(obj), min_tlab_size, new_tlab_size); AllocTracer::send_allocation_in_new_tlab(klass, obj, actual_tlab_size * HeapWordSize, size * HeapWordSize, thread); @@ -513,9 +513,9 @@ fill_with_object_impl(start, words, zap); } -HeapWord* CollectedHeap::allocate_new_tlab(size_t min_word_size, - size_t desired_word_size, - size_t* actual_word_size) { +HeapWord* CollectedHeap::allocate_new_tlab(size_t min_size, + size_t requested_size, + size_t* actual_size) { guarantee(false, "thread-local allocation buffers not supported"); return NULL; } --- old/src/hotspot/share/gc/shared/collectedHeap.hpp 2018-05-02 11:21:18.708942383 +0200 +++ new/src/hotspot/share/gc/shared/collectedHeap.hpp 2018-05-02 11:21:18.360928613 +0200 @@ -126,13 +126,13 @@ CollectedHeap(); // Create a new tlab. All TLAB allocations must go through this. - // To allow more flexible TLAB allocations min_word_size specifies - // the minimum size needed, while desired_word_size is the requested + // To allow more flexible TLAB allocations min_size specifies + // the minimum size needed, while requested_size is the requested // size based on ergonomics. The actually allocated size will be - // returned in actual_word_size. - virtual HeapWord* allocate_new_tlab(size_t min_word_size, - size_t desired_word_size, - size_t* actual_word_size); + // returned in actual_size. + virtual HeapWord* allocate_new_tlab(size_t min_size, + size_t requested_size, + size_t* actual_size); // Accumulate statistics on all tlabs. virtual void accumulate_statistics_all_tlabs(); --- old/src/hotspot/share/gc/shared/genCollectedHeap.cpp 2018-05-02 11:21:19.648979579 +0200 +++ new/src/hotspot/share/gc/shared/genCollectedHeap.cpp 2018-05-02 11:21:19.296965650 +0200 @@ -1146,15 +1146,15 @@ return 0; } -HeapWord* GenCollectedHeap::allocate_new_tlab(size_t min_word_size, - size_t desired_word_size, - size_t* actual_word_size) { +HeapWord* GenCollectedHeap::allocate_new_tlab(size_t min_size, + size_t requested_size, + size_t* actual_size) { bool gc_overhead_limit_was_exceeded; - HeapWord* result = mem_allocate_work(desired_word_size /* size */, + HeapWord* result = mem_allocate_work(requested_size /* size */, true /* is_tlab */, &gc_overhead_limit_was_exceeded); if (result != NULL) { - *actual_word_size = desired_word_size; + *actual_size = requested_size; } return result; --- old/src/hotspot/share/gc/shared/genCollectedHeap.hpp 2018-05-02 11:21:20.665019781 +0200 +++ new/src/hotspot/share/gc/shared/genCollectedHeap.hpp 2018-05-02 11:21:20.293005062 +0200 @@ -297,9 +297,9 @@ virtual size_t tlab_capacity(Thread* thr) const; virtual size_t tlab_used(Thread* thr) const; virtual size_t unsafe_max_tlab_alloc(Thread* thr) const; - virtual HeapWord* allocate_new_tlab(size_t min_word_size, - size_t desired_word_size, - size_t* actual_word_size); + virtual HeapWord* allocate_new_tlab(size_t min_size, + size_t requested_size, + size_t* actual_size); // The "requestor" generation is performing some garbage collection // action for which it would be useful to have scratch space. The --- old/src/hotspot/share/gc/shared/threadLocalAllocBuffer.inline.hpp 2018-05-02 11:21:21.681059984 +0200 +++ new/src/hotspot/share/gc/shared/threadLocalAllocBuffer.inline.hpp 2018-05-02 11:21:21.325045897 +0200 @@ -75,7 +75,8 @@ inline size_t ThreadLocalAllocBuffer::compute_min_size(size_t obj_size) { const size_t aligned_obj_size = align_object_size(obj_size); - return aligned_obj_size + alignment_reserve(); + const size_t size_with_reserve = aligned_obj_size + alignment_reserve(); + return MAX2(size_with_reserve, MinTLABSize); } void ThreadLocalAllocBuffer::record_slow_allocation(size_t obj_size) {