Derive CpuCache/HugePageAwareAllocator shims directly from Parameters.

tcmalloc/cpu_cache.h

@@ -96,8 +96,13 @@ constexpr inline uint8_t kTotalPossibleSlabs =
 // This is a class, rather than namespaced globals, so that it can be mocked for
 // testing.
 template <typename State>
-class StaticForwarder {
+class StaticForwarder : private Parameters {
  public:
+  using Parameters::per_cpu_caches_dynamic_slab_enabled;
+  using Parameters::per_cpu_caches_dynamic_slab_grow_threshold;
+  using Parameters::per_cpu_caches_dynamic_slab_shrink_threshold;
+  using Parameters::release_drained_slab_metadata;
+
   constexpr explicit StaticForwarder(State& state) : state_(state) {}
 
   [[nodiscard]] void* absl_nonnull Alloc(size_t size,
@@ -146,21 +151,6 @@ class StaticForwarder {
     state_.arena().UpdateAllocatedAndNonresident(allocated, nonresident);
   }
 
-  static bool per_cpu_caches_dynamic_slab_enabled() {
-    return Parameters::per_cpu_caches_dynamic_slab_enabled();
-  }
-
-  static double per_cpu_caches_dynamic_slab_grow_threshold() {
-    return Parameters::per_cpu_caches_dynamic_slab_grow_threshold();
-  }
-
-  static double per_cpu_caches_dynamic_slab_shrink_threshold() {
-    return Parameters::per_cpu_caches_dynamic_slab_shrink_threshold();
-  }
-
-  static bool release_drained_slab_metadata() {
-    return Parameters::release_drained_slab_metadata();
-  }
 
   bool reuse_size_classes() const {
     return state_.size_class_configuration() ==

tcmalloc/cpu_cache_test.cc

@@ -133,8 +133,10 @@ namespace {
 
 enum class DynamicSlab { kGrow, kShrink, kNoop };
 
-class TestStaticForwarder {
+class TestStaticForwarder : private Parameters {
  public:
+  using Parameters::per_cpu_caches_dynamic_slab_grow_threshold;
+  using Parameters::per_cpu_caches_dynamic_slab_shrink_threshold;
   TestStaticForwarder() : sharded_manager_(&owner_, &cpu_layout_) {
     numa_topology_.Init();
 

tcmalloc/huge_page_aware_allocator.h

@@ -61,45 +61,18 @@ bool decide_subrelease();
 HugeRegionUsageOption huge_region_option();
 bool use_huge_region_more_often();
 
-class StaticForwarder {
+class StaticForwarder : private Parameters {
  public:
-  // Runtime parameters.  This can change between calls.
-  static absl::Duration filler_skip_subrelease_short_interval() {
-    return Parameters::filler_skip_subrelease_short_interval();
-  }
-  static absl::Duration filler_skip_subrelease_long_interval() {
-    return Parameters::filler_skip_subrelease_long_interval();
-  }
-
-  static bool release_partial_alloc_pages() {
-    return Parameters::release_partial_alloc_pages();
-  }
-
-  static SubreleaseUnbackedMode subrelease_unbacked_hugepages() {
-    return Parameters::subrelease_unbacked_hugepages();
-  }
-
-  static bool hpaa_subrelease() { return Parameters::hpaa_subrelease(); }
-
-  static EnableUnfilteredCollapse enable_unfiltered_collapse() {
-    return Parameters::enable_unfiltered_collapse();
-  }
-
-  static bool huge_region_adaptive_release() {
-    return Parameters::huge_region_adaptive_release();
-  }
-
-  static bool release_max_cold_pages() {
-    return Parameters::release_max_cold_pages();
-  }
-
-  static ReleaseStalePages release_stale_pages() {
-    return Parameters::release_stale_pages();
-  }
-
-  static MadviseRegionsNoHugepage madvise_cold_regions_nohugepage() {
-    return Parameters::madvise_cold_regions_nohugepage();
-  }
+  using Parameters::enable_unfiltered_collapse;
+  using Parameters::filler_skip_subrelease_long_interval;
+  using Parameters::filler_skip_subrelease_short_interval;
+  using Parameters::hpaa_subrelease;
+  using Parameters::huge_region_adaptive_release;
+  using Parameters::madvise_cold_regions_nohugepage;
+  using Parameters::release_max_cold_pages;
+  using Parameters::release_partial_alloc_pages;
+  using Parameters::release_stale_pages;
+  using Parameters::subrelease_unbacked_hugepages;
 
   // Arena state.
   static Arena& arena();
@@ -140,12 +113,10 @@ class StaticForwarder {
   // SystemAlloc state.
   [[nodiscard]] static AddressRange AllocatePages(size_t bytes, size_t align,
                                                   MemoryTag tag);
-  static bool BackAllocations() {
-    return Parameters::back_small_allocations();
-  };
+  static bool BackAllocations() { return back_small_allocations(); }
   static int32_t BackSizeThresholdBytes() {
-    return Parameters::back_size_threshold_bytes();
-  };
+    return back_size_threshold_bytes();
+  }
   static void Back(Range r);
   [[nodiscard]] static MemoryModifyStatus ReleasePages(Range r);
   [[nodiscard]] static MemoryModifyStatus CollapsePages(Range r);

tcmalloc/mock_huge_page_static_forwarder.h

@@ -40,23 +40,26 @@
 #include "tcmalloc/internal/memory_tag.h"
 #include "tcmalloc/internal/system_allocator.h"
 #include "tcmalloc/pages.h"
+#include "tcmalloc/parameters.h"
 #include "tcmalloc/span.h"
 
 GOOGLE_MALLOC_SECTION_BEGIN
 namespace tcmalloc {
 namespace tcmalloc_internal {
 namespace huge_page_allocator_internal {
 
-class FakeStaticForwarder {
+class FakeStaticForwarder : private Parameters {
  public:
   // Runtime parameters.  This can change between calls.
-  absl::Duration filler_skip_subrelease_short_interval() {
+  absl::Duration filler_skip_subrelease_short_interval() const {
     return short_interval_;
   }
-  absl::Duration filler_skip_subrelease_long_interval() {
+  absl::Duration filler_skip_subrelease_long_interval() const {
     return long_interval_;
   }
-  bool release_partial_alloc_pages() { return release_partial_alloc_pages_; }
+  bool release_partial_alloc_pages() const {
+    return release_partial_alloc_pages_;
+  }
   bool hpaa_subrelease() const { return hpaa_subrelease_; }
   SubreleaseUnbackedMode subrelease_unbacked_hugepages() const {
     return subrelease_unbacked_hugepages_;
@@ -117,6 +120,9 @@ class FakeStaticForwarder {
     enable_unfiltered_collapse_ = value ? EnableUnfilteredCollapse::kEnabled
                                         : EnableUnfilteredCollapse::kDisabled;
   }
+  void set_enable_unfiltered_collapse(EnableUnfilteredCollapse value) {
+    enable_unfiltered_collapse_ = value;
+  }
 
   // Arena state.
   Arena& arena() { return arena_; }
@@ -226,26 +232,29 @@ class FakeStaticForwarder {
     });
     return a;
   }
-  absl::Duration short_interval_ = absl::Seconds(60);
-  absl::Duration long_interval_ = absl::Seconds(300);
-  bool release_partial_alloc_pages_ = false;
-  bool hpaa_subrelease_ = true;
+  absl::Duration short_interval_ =
+      Parameters::filler_skip_subrelease_short_interval();
+  absl::Duration long_interval_ =
+      Parameters::filler_skip_subrelease_long_interval();
+  bool release_partial_alloc_pages_ = Parameters::release_partial_alloc_pages();
+  bool hpaa_subrelease_ = Parameters::hpaa_subrelease();
   SubreleaseUnbackedMode subrelease_unbacked_hugepages_ =
-      SubreleaseUnbackedMode::kEnabled;
+      Parameters::subrelease_unbacked_hugepages();
   bool release_succeeds_ = true;
   bool collapse_succeeds_ = true;
   int error_number_ = 0;
-  bool huge_region_adaptive_release_ = false;
-  bool release_max_cold_pages_ = false;
+  bool huge_region_adaptive_release_ =
+      Parameters::huge_region_adaptive_release();
+  bool release_max_cold_pages_ = Parameters::release_max_cold_pages();
 
-  bool back_allocations_ = false;
-  int32_t back_size_threshold_bytes_ = kPageSize;
+  bool back_allocations_ = Parameters::back_small_allocations();
+  int32_t back_size_threshold_bytes_ = Parameters::back_size_threshold_bytes();
   EnableUnfilteredCollapse enable_unfiltered_collapse_ =
-      EnableUnfilteredCollapse::kDisabled;
+      Parameters::enable_unfiltered_collapse();
   Arena arena_;
-  ReleaseStalePages release_stale_pages_ = ReleaseStalePages::kDisabled;
+  ReleaseStalePages release_stale_pages_ = Parameters::release_stale_pages();
   MadviseRegionsNoHugepage madvise_cold_regions_nohugepage_ =
-      MadviseRegionsNoHugepage::kDisabled;
+      Parameters::madvise_cold_regions_nohugepage();
 
   std::atomic<uintptr_t> fake_allocation_ = 0x1000;