Remove Thread argument from tlab functions in CH

jsikstro · jsikstro · commit 5a0a152af13d · 2025-10-16T12:57:22.000+02:00
diff --git a/src/hotspot/share/gc/epsilon/epsilonHeap.cpp b/src/hotspot/share/gc/epsilon/epsilonHeap.cpp
@@ -91,7 +91,7 @@ GrowableArray<MemoryPool*> EpsilonHeap::memory_pools() {
   return memory_pools;
 }
 
-size_t EpsilonHeap::unsafe_max_tlab_alloc(Thread* thr) const {
+size_t EpsilonHeap::unsafe_max_tlab_alloc() const {
   // Return max allocatable TLAB size, and let allocation path figure out
   // the actual allocation size. Note: result should be in bytes.
   return _max_tlab_size * HeapWordSize;
diff --git a/src/hotspot/share/gc/epsilon/epsilonHeap.hpp b/src/hotspot/share/gc/epsilon/epsilonHeap.hpp
@@ -90,10 +90,10 @@ class EpsilonHeap : public CollectedHeap {
                               size_t* actual_size) override;
 
   // TLAB allocation
-  size_t tlab_capacity(Thread* thr)         const override { return capacity();     }
-  size_t tlab_used(Thread* thr)             const override { return used();         }
-  size_t max_tlab_size()                    const override { return _max_tlab_size; }
-  size_t unsafe_max_tlab_alloc(Thread* thr) const override;
+  size_t tlab_capacity()         const override { return capacity();     }
+  size_t tlab_used()             const override { return used();         }
+  size_t max_tlab_size()         const override { return _max_tlab_size; }
+  size_t unsafe_max_tlab_alloc() const override;
 
   void collect(GCCause::Cause cause) override;
   void do_full_collection(bool clear_all_soft_refs) override;
diff --git a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp
@@ -2192,11 +2192,11 @@ bool G1CollectedHeap::block_is_obj(const HeapWord* addr) const {
   return hr->block_is_obj(addr, hr->parsable_bottom_acquire());
 }
 
-size_t G1CollectedHeap::tlab_capacity(Thread* ignored) const {
+size_t G1CollectedHeap::tlab_capacity() const {
   return eden_target_length() * G1HeapRegion::GrainBytes;
 }
 
-size_t G1CollectedHeap::tlab_used(Thread* ignored) const {
+size_t G1CollectedHeap::tlab_used() const {
   return _eden.length() * G1HeapRegion::GrainBytes;
 }
 
@@ -2206,7 +2206,7 @@ size_t G1CollectedHeap::max_tlab_size() const {
   return align_down(_humongous_object_threshold_in_words, MinObjAlignment);
 }
 
-size_t G1CollectedHeap::unsafe_max_tlab_alloc(Thread* ignored) const {
+size_t G1CollectedHeap::unsafe_max_tlab_alloc() const {
   return _allocator->unsafe_max_tlab_alloc();
 }
 
diff --git a/src/hotspot/share/gc/g1/g1CollectedHeap.hpp b/src/hotspot/share/gc/g1/g1CollectedHeap.hpp
@@ -1193,10 +1193,10 @@ class G1CollectedHeap : public CollectedHeap {
   // Section on thread-local allocation buffers (TLABs)
   // See CollectedHeap for semantics.
 
-  size_t tlab_capacity(Thread* ignored) const override;
-  size_t tlab_used(Thread* ignored) const override;
+  size_t tlab_capacity() const override;
+  size_t tlab_used() const override;
   size_t max_tlab_size() const override;
-  size_t unsafe_max_tlab_alloc(Thread* ignored) const override;
+  size_t unsafe_max_tlab_alloc() const override;
 
   inline bool is_in_young(const oop obj) const;
   inline bool requires_barriers(stackChunkOop obj) const override;
diff --git a/src/hotspot/share/gc/parallel/mutableNUMASpace.cpp b/src/hotspot/share/gc/parallel/mutableNUMASpace.cpp
@@ -118,23 +118,23 @@ size_t MutableNUMASpace::free_in_words() const {
   return s;
 }
 
-size_t MutableNUMASpace::tlab_capacity(Thread *ignored) const {
+size_t MutableNUMASpace::tlab_capacity() const {
   size_t s = 0;
   for (LGRPSpace* ls : *lgrp_spaces()) {
     s += ls->space()->capacity_in_bytes();
   }
   return s / (size_t)lgrp_spaces()->length();
 }
 
-size_t MutableNUMASpace::tlab_used(Thread *ignored) const {
+size_t MutableNUMASpace::tlab_used() const {
   size_t s = 0;
   for (LGRPSpace* ls : *lgrp_spaces()) {
     s += ls->space()->used_in_bytes();
   }
   return s / (size_t)lgrp_spaces()->length();
 }
 
-size_t MutableNUMASpace::unsafe_max_tlab_alloc(Thread *ignored) const {
+size_t MutableNUMASpace::unsafe_max_tlab_alloc() const {
   size_t s = 0;
   for (LGRPSpace* ls : *lgrp_spaces()) {
     s += ls->space()->free_in_bytes();
diff --git a/src/hotspot/share/gc/parallel/mutableNUMASpace.hpp b/src/hotspot/share/gc/parallel/mutableNUMASpace.hpp
@@ -176,9 +176,9 @@ class MutableNUMASpace : public MutableSpace {
   virtual size_t used_in_words() const;
   virtual size_t free_in_words() const;
 
-  virtual size_t tlab_capacity(Thread* ignored) const;
-  virtual size_t tlab_used(Thread* ignored) const;
-  virtual size_t unsafe_max_tlab_alloc(Thread* ignored) const;
+  virtual size_t tlab_capacity() const;
+  virtual size_t tlab_used() const;
+  virtual size_t unsafe_max_tlab_alloc() const;
 
   // Allocation (return null if full)
   virtual HeapWord* cas_allocate(size_t word_size);
diff --git a/src/hotspot/share/gc/parallel/mutableSpace.hpp b/src/hotspot/share/gc/parallel/mutableSpace.hpp
@@ -116,11 +116,11 @@ class MutableSpace: public CHeapObj<mtGC> {
   size_t free_in_bytes() const                { return free_in_words() * HeapWordSize; }
 
   // Size computations.  Sizes are in heapwords.
-  virtual size_t used_in_words() const                    { return pointer_delta(top(), bottom()); }
-  virtual size_t free_in_words() const                    { return pointer_delta(end(),    top()); }
-  virtual size_t tlab_capacity(Thread* thr) const         { return capacity_in_bytes();            }
-  virtual size_t tlab_used(Thread* thr) const             { return used_in_bytes();                }
-  virtual size_t unsafe_max_tlab_alloc(Thread* thr) const { return free_in_bytes();                }
+  virtual size_t used_in_words() const         { return pointer_delta(top(), bottom()); }
+  virtual size_t free_in_words() const         { return pointer_delta(end(),    top()); }
+  virtual size_t tlab_capacity() const         { return capacity_in_bytes();            }
+  virtual size_t tlab_used() const             { return used_in_bytes();                }
+  virtual size_t unsafe_max_tlab_alloc() const { return free_in_bytes();                }
 
   // Allocation (return null if full)
   virtual HeapWord* cas_allocate(size_t word_size);
diff --git a/src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp b/src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp
@@ -434,16 +434,16 @@ void ParallelScavengeHeap::ensure_parsability(bool retire_tlabs) {
   young_gen()->eden_space()->ensure_parsability();
 }
 
-size_t ParallelScavengeHeap::tlab_capacity(Thread* thr) const {
-  return young_gen()->eden_space()->tlab_capacity(thr);
+size_t ParallelScavengeHeap::tlab_capacity() const {
+  return young_gen()->eden_space()->tlab_capacity();
 }
 
-size_t ParallelScavengeHeap::tlab_used(Thread* thr) const {
-  return young_gen()->eden_space()->tlab_used(thr);
+size_t ParallelScavengeHeap::tlab_used() const {
+  return young_gen()->eden_space()->tlab_used();
 }
 
-size_t ParallelScavengeHeap::unsafe_max_tlab_alloc(Thread* thr) const {
-  return young_gen()->eden_space()->unsafe_max_tlab_alloc(thr);
+size_t ParallelScavengeHeap::unsafe_max_tlab_alloc() const {
+  return young_gen()->eden_space()->unsafe_max_tlab_alloc();
 }
 
 HeapWord* ParallelScavengeHeap::allocate_new_tlab(size_t min_size, size_t requested_size, size_t* actual_size) {
diff --git a/src/hotspot/share/gc/parallel/parallelScavengeHeap.hpp b/src/hotspot/share/gc/parallel/parallelScavengeHeap.hpp
@@ -199,9 +199,9 @@ class ParallelScavengeHeap : public CollectedHeap {
   void ensure_parsability(bool retire_tlabs) override;
   void resize_all_tlabs() override;
 
-  size_t tlab_capacity(Thread* thr) const override;
-  size_t tlab_used(Thread* thr) const override;
-  size_t unsafe_max_tlab_alloc(Thread* thr) const override;
+  size_t tlab_capacity() const override;
+  size_t tlab_used() const override;
+  size_t unsafe_max_tlab_alloc() const override;
 
   void object_iterate(ObjectClosure* cl) override;
   void object_iterate_parallel(ObjectClosure* cl, HeapBlockClaimer* claimer);
diff --git a/src/hotspot/share/gc/serial/serialHeap.cpp b/src/hotspot/share/gc/serial/serialHeap.cpp
@@ -651,16 +651,16 @@ bool SerialHeap::block_is_obj(const HeapWord* addr) const {
   return addr < _old_gen->space()->top();
 }
 
-size_t SerialHeap::tlab_capacity(Thread* thr) const {
+size_t SerialHeap::tlab_capacity() const {
   // Only young-gen supports tlab allocation.
   return _young_gen->tlab_capacity();
 }
 
-size_t SerialHeap::tlab_used(Thread* thr) const {
+size_t SerialHeap::tlab_used() const {
   return _young_gen->tlab_used();
 }
 
-size_t SerialHeap::unsafe_max_tlab_alloc(Thread* thr) const {
+size_t SerialHeap::unsafe_max_tlab_alloc() const {
   return _young_gen->unsafe_max_tlab_alloc();
 }
 
diff --git a/src/hotspot/share/gc/serial/serialHeap.hpp b/src/hotspot/share/gc/serial/serialHeap.hpp
@@ -189,9 +189,9 @@ class SerialHeap : public CollectedHeap {
   bool block_is_obj(const HeapWord* addr) const;
 
   // Section on TLAB's.
-  size_t tlab_capacity(Thread* thr) const override;
-  size_t tlab_used(Thread* thr) const override;
-  size_t unsafe_max_tlab_alloc(Thread* thr) const override;
+  size_t tlab_capacity() const override;
+  size_t tlab_used() const override;
+  size_t unsafe_max_tlab_alloc() const override;
   HeapWord* allocate_new_tlab(size_t min_size,
                               size_t requested_size,
                               size_t* actual_size) override;
diff --git a/src/hotspot/share/gc/shared/collectedHeap.hpp b/src/hotspot/share/gc/shared/collectedHeap.hpp
@@ -345,17 +345,17 @@ class CollectedHeap : public CHeapObj<mtGC> {
   virtual void ensure_parsability(bool retire_tlabs);
 
   // The amount of space available for thread-local allocation buffers.
-  virtual size_t tlab_capacity(Thread *thr) const = 0;
+  virtual size_t tlab_capacity() const = 0;
 
-  // The amount of used space for thread-local allocation buffers for the given thread.
-  virtual size_t tlab_used(Thread *thr) const = 0;
+  // The amount of used space for thread-local allocation buffers.
+  virtual size_t tlab_used() const = 0;
 
   virtual size_t max_tlab_size() const;
 
   // An estimate of the maximum allocation that could be performed
   // for thread-local allocation buffers without triggering any
   // collection or expansion activity.
-  virtual size_t unsafe_max_tlab_alloc(Thread *thr) const = 0;
+  virtual size_t unsafe_max_tlab_alloc() const = 0;
 
   // Perform a collection of the heap; intended for use in implementing
   // "System.gc".  This probably implies as full a collection as the
diff --git a/src/hotspot/share/gc/shared/threadLocalAllocBuffer.cpp b/src/hotspot/share/gc/shared/threadLocalAllocBuffer.cpp
@@ -72,12 +72,11 @@ size_t ThreadLocalAllocBuffer::remaining() {
 }
 
 void ThreadLocalAllocBuffer::accumulate_and_reset_statistics(ThreadLocalAllocStats* stats) {
-  Thread* thr     = thread();
-  size_t capacity = Universe::heap()->tlab_capacity(thr);
-  size_t used     = Universe::heap()->tlab_used(thr);
+  size_t capacity = Universe::heap()->tlab_capacity();
+  size_t used     = Universe::heap()->tlab_used();
 
   _gc_waste += (unsigned)remaining();
-  size_t total_allocated = thr->allocated_bytes();
+  size_t total_allocated = (size_t)thread()->allocated_bytes();
   size_t allocated_since_last_gc = total_allocated - _allocated_before_last_gc;
   _allocated_before_last_gc = total_allocated;
 
@@ -148,7 +147,7 @@ void ThreadLocalAllocBuffer::resize() {
   // Compute the next tlab size using expected allocation amount
   assert(ResizeTLAB, "Should not call this otherwise");
   size_t alloc = (size_t)(_allocation_fraction.average() *
-                          (Universe::heap()->tlab_capacity(thread()) / HeapWordSize));
+                          (Universe::heap()->tlab_capacity() / HeapWordSize));
   size_t new_size = alloc / _target_refills;
 
   new_size = clamp(new_size, min_size(), max_size());
@@ -204,7 +203,7 @@ void ThreadLocalAllocBuffer::initialize() {
 
   set_desired_size(initial_desired_size());
 
-  size_t capacity = Universe::heap()->tlab_capacity(thread()) / HeapWordSize;
+  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;
@@ -268,7 +267,7 @@ size_t ThreadLocalAllocBuffer::initial_desired_size() {
     // Initial size is a function of the average number of allocating threads.
     unsigned int nof_threads = ThreadLocalAllocStats::allocating_threads_avg();
 
-    init_sz  = (Universe::heap()->tlab_capacity(thread()) / HeapWordSize) /
+    init_sz  = (Universe::heap()->tlab_capacity() / HeapWordSize) /
                       (nof_threads * target_refills());
     init_sz = align_object_size(init_sz);
   }
@@ -286,16 +285,15 @@ void ThreadLocalAllocBuffer::print_stats(const char* tag) {
     return;
   }
 
-  Thread* thrd = thread();
   size_t waste = _gc_waste + _refill_waste;
   double waste_percent = percent_of(waste, _allocated_size);
-  size_t tlab_used  = Universe::heap()->tlab_used(thrd);
+  size_t tlab_used  = Universe::heap()->tlab_used();
   log.trace("TLAB: %s thread: " PTR_FORMAT " [id: %2d]"
             " desired_size: %zuKB"
             " slow allocs: %d  refill waste: %zuB"
             " alloc:%8.5f %8.0fKB refills: %d waste %4.1f%% gc: %dB"
             " slow: %dB",
-            tag, p2i(thrd), thrd->osthread()->thread_id(),
+            tag, p2i(thread()), thread()->osthread()->thread_id(),
             _desired_size / (K / HeapWordSize),
             _slow_allocations, _refill_waste_limit * HeapWordSize,
             _allocation_fraction.average(),
diff --git a/src/hotspot/share/gc/shared/threadLocalAllocBuffer.inline.hpp b/src/hotspot/share/gc/shared/threadLocalAllocBuffer.inline.hpp
@@ -55,7 +55,7 @@ inline size_t ThreadLocalAllocBuffer::compute_size(size_t obj_size) {
   // Compute the size for the new TLAB.
   // The "last" tlab may be smaller to reduce fragmentation.
   // unsafe_max_tlab_alloc is just a hint.
-  const size_t available_size = Universe::heap()->unsafe_max_tlab_alloc(thread()) / HeapWordSize;
+  const size_t available_size = Universe::heap()->unsafe_max_tlab_alloc() / HeapWordSize;
   size_t new_tlab_size = MIN3(available_size, desired_size() + align_object_size(obj_size), max_size());
 
   // Make sure there's enough room for object and filler int[].
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp
@@ -1559,7 +1559,7 @@ void ShenandoahHeap::gclabs_retire(bool resize) {
 }
 
 // Returns size in bytes
-size_t ShenandoahHeap::unsafe_max_tlab_alloc(Thread *thread) const {
+size_t ShenandoahHeap::unsafe_max_tlab_alloc() const {
   // Return the max allowed size, and let the allocation path
   // figure out the safe size for current allocation.
   return ShenandoahHeapRegion::max_tlab_size_bytes();
@@ -1708,7 +1708,7 @@ void ShenandoahHeap::verify(VerifyOption vo) {
     }
   }
 }
-size_t ShenandoahHeap::tlab_capacity(Thread *thr) const {
+size_t ShenandoahHeap::tlab_capacity() const {
   return _free_set->capacity();
 }
 
@@ -2185,7 +2185,7 @@ GCTracer* ShenandoahHeap::tracer() {
   return shenandoah_policy()->tracer();
 }
 
-size_t ShenandoahHeap::tlab_used(Thread* thread) const {
+size_t ShenandoahHeap::tlab_used() const {
   return _free_set->used();
 }
 
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp
@@ -719,10 +719,10 @@ class ShenandoahHeap : public CollectedHeap {
   void notify_mutator_alloc_words(size_t words, size_t waste);
 
   HeapWord* allocate_new_tlab(size_t min_size, size_t requested_size, size_t* actual_size) override;
-  size_t tlab_capacity(Thread *thr) const override;
-  size_t unsafe_max_tlab_alloc(Thread *thread) const override;
+  size_t tlab_capacity() const override;
+  size_t unsafe_max_tlab_alloc() const override;
   size_t max_tlab_size() const override;
-  size_t tlab_used(Thread* ignored) const override;
+  size_t tlab_used() const override;
 
   void ensure_parsability(bool retire_labs) override;
 
diff --git a/src/hotspot/share/gc/z/zCollectedHeap.cpp b/src/hotspot/share/gc/z/zCollectedHeap.cpp
@@ -222,19 +222,19 @@ void ZCollectedHeap::do_full_collection(bool clear_all_soft_refs) {
   ShouldNotReachHere();
 }
 
-size_t ZCollectedHeap::tlab_capacity(Thread* ignored) const {
+size_t ZCollectedHeap::tlab_capacity() const {
   return _heap.tlab_capacity();
 }
 
-size_t ZCollectedHeap::tlab_used(Thread* ignored) const {
+size_t ZCollectedHeap::tlab_used() const {
   return _heap.tlab_used();
 }
 
 size_t ZCollectedHeap::max_tlab_size() const {
   return _heap.max_tlab_size() / HeapWordSize;
 }
 
-size_t ZCollectedHeap::unsafe_max_tlab_alloc(Thread* ignored) const {
+size_t ZCollectedHeap::unsafe_max_tlab_alloc() const {
   return _heap.unsafe_max_tlab_alloc();
 }
 
diff --git a/src/hotspot/share/gc/z/zCollectedHeap.hpp b/src/hotspot/share/gc/z/zCollectedHeap.hpp
@@ -83,10 +83,10 @@ class ZCollectedHeap : public CollectedHeap {
   void collect_as_vm_thread(GCCause::Cause cause) override;
   void do_full_collection(bool clear_all_soft_refs) override;
 
-  size_t tlab_capacity(Thread* thr) const override;
-  size_t tlab_used(Thread* thr) const override;
+  size_t tlab_capacity() const override;
+  size_t tlab_used() const override;
   size_t max_tlab_size() const override;
-  size_t unsafe_max_tlab_alloc(Thread* thr) const override;
+  size_t unsafe_max_tlab_alloc() const override;
 
   MemoryUsage memory_usage() override;
   GrowableArray<GCMemoryManager*> memory_managers() override;

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ GrowableArray<MemoryPool*> EpsilonHeap::memory_pools() {`
`91`	`91`	`return memory_pools;`
`92`	`92`	`}`
`93`	`93`
`94`		`-size_t EpsilonHeap::unsafe_max_tlab_alloc(Thread* thr) const {`
	`94`	`+size_t EpsilonHeap::unsafe_max_tlab_alloc() const {`
`95`	`95`	`// Return max allocatable TLAB size, and let allocation path figure out`
`96`	`96`	`// the actual allocation size. Note: result should be in bytes.`
`97`	`97`	`return _max_tlab_size * HeapWordSize;`
Original file line number	Diff line number	Diff line change
`@@ -2192,11 +2192,11 @@ bool G1CollectedHeap::block_is_obj(const HeapWord* addr) const {`
`2192`	`2192`	`return hr->block_is_obj(addr, hr->parsable_bottom_acquire());`
`2193`	`2193`	`}`
`2194`	`2194`
`2195`		`-size_t G1CollectedHeap::tlab_capacity(Thread* ignored) const {`
	`2195`	`+size_t G1CollectedHeap::tlab_capacity() const {`
`2196`	`2196`	`return eden_target_length() * G1HeapRegion::GrainBytes;`
`2197`	`2197`	`}`
`2198`	`2198`
`2199`		`-size_t G1CollectedHeap::tlab_used(Thread* ignored) const {`
	`2199`	`+size_t G1CollectedHeap::tlab_used() const {`
`2200`	`2200`	`return _eden.length() * G1HeapRegion::GrainBytes;`
`2201`	`2201`	`}`
`2202`	`2202`
`@@ -2206,7 +2206,7 @@ size_t G1CollectedHeap::max_tlab_size() const {`
`2206`	`2206`	`return align_down(_humongous_object_threshold_in_words, MinObjAlignment);`
`2207`	`2207`	`}`
`2208`	`2208`
`2209`		`-size_t G1CollectedHeap::unsafe_max_tlab_alloc(Thread* ignored) const {`
	`2209`	`+size_t G1CollectedHeap::unsafe_max_tlab_alloc() const {`
`2210`	`2210`	`return _allocator->unsafe_max_tlab_alloc();`
`2211`	`2211`	`}`
`2212`	`2212`
Original file line number	Diff line number	Diff line change
`@@ -118,23 +118,23 @@ size_t MutableNUMASpace::free_in_words() const {`
`118`	`118`	`return s;`
`119`	`119`	`}`
`120`	`120`
`121`		`-size_t MutableNUMASpace::tlab_capacity(Thread *ignored) const {`
	`121`	`+size_t MutableNUMASpace::tlab_capacity() const {`
`122`	`122`	`size_t s = 0;`
`123`	`123`	`for (LGRPSpace* ls : *lgrp_spaces()) {`
`124`	`124`	`s += ls->space()->capacity_in_bytes();`
`125`	`125`	`}`
`126`	`126`	`return s / (size_t)lgrp_spaces()->length();`
`127`	`127`	`}`
`128`	`128`
`129`		`-size_t MutableNUMASpace::tlab_used(Thread *ignored) const {`
	`129`	`+size_t MutableNUMASpace::tlab_used() const {`
`130`	`130`	`size_t s = 0;`
`131`	`131`	`for (LGRPSpace* ls : *lgrp_spaces()) {`
`132`	`132`	`s += ls->space()->used_in_bytes();`
`133`	`133`	`}`
`134`	`134`	`return s / (size_t)lgrp_spaces()->length();`
`135`	`135`	`}`
`136`	`136`
`137`		`-size_t MutableNUMASpace::unsafe_max_tlab_alloc(Thread *ignored) const {`
	`137`	`+size_t MutableNUMASpace::unsafe_max_tlab_alloc() const {`
`138`	`138`	`size_t s = 0;`
`139`	`139`	`for (LGRPSpace* ls : *lgrp_spaces()) {`
`140`	`140`	`s += ls->space()->free_in_bytes();`
Original file line number	Diff line number	Diff line change
`@@ -434,16 +434,16 @@ void ParallelScavengeHeap::ensure_parsability(bool retire_tlabs) {`
`434`	`434`	`young_gen()->eden_space()->ensure_parsability();`
`435`	`435`	`}`
`436`	`436`
`437`		`-size_t ParallelScavengeHeap::tlab_capacity(Thread* thr) const {`
`438`		`- return young_gen()->eden_space()->tlab_capacity(thr);`
	`437`	`+size_t ParallelScavengeHeap::tlab_capacity() const {`
	`438`	`+ return young_gen()->eden_space()->tlab_capacity();`
`439`	`439`	`}`
`440`	`440`
`441`		`-size_t ParallelScavengeHeap::tlab_used(Thread* thr) const {`
`442`		`- return young_gen()->eden_space()->tlab_used(thr);`
	`441`	`+size_t ParallelScavengeHeap::tlab_used() const {`
	`442`	`+ return young_gen()->eden_space()->tlab_used();`
`443`	`443`	`}`
`444`	`444`
`445`		`-size_t ParallelScavengeHeap::unsafe_max_tlab_alloc(Thread* thr) const {`
`446`		`- return young_gen()->eden_space()->unsafe_max_tlab_alloc(thr);`
	`445`	`+size_t ParallelScavengeHeap::unsafe_max_tlab_alloc() const {`
	`446`	`+ return young_gen()->eden_space()->unsafe_max_tlab_alloc();`
`447`	`447`	`}`
`448`	`448`
`449`	`449`	`HeapWord* ParallelScavengeHeap::allocate_new_tlab(size_t min_size, size_t requested_size, size_t* actual_size) {`
Original file line number	Diff line number	Diff line change
`@@ -651,16 +651,16 @@ bool SerialHeap::block_is_obj(const HeapWord* addr) const {`
`651`	`651`	`return addr < _old_gen->space()->top();`
`652`	`652`	`}`
`653`	`653`
`654`		`-size_t SerialHeap::tlab_capacity(Thread* thr) const {`
	`654`	`+size_t SerialHeap::tlab_capacity() const {`
`655`	`655`	`// Only young-gen supports tlab allocation.`
`656`	`656`	`return _young_gen->tlab_capacity();`
`657`	`657`	`}`
`658`	`658`
`659`		`-size_t SerialHeap::tlab_used(Thread* thr) const {`
	`659`	`+size_t SerialHeap::tlab_used() const {`
`660`	`660`	`return _young_gen->tlab_used();`
`661`	`661`	`}`
`662`	`662`
`663`		`-size_t SerialHeap::unsafe_max_tlab_alloc(Thread* thr) const {`
	`663`	`+size_t SerialHeap::unsafe_max_tlab_alloc() const {`
`664`	`664`	`return _young_gen->unsafe_max_tlab_alloc();`
`665`	`665`	`}`
`666`	`666`