Remove the enum for dense tracker type in the HugePageFiller

We no longer need it.  The dense trackers are now always sorted on number of
spans allocated.

PiperOrigin-RevId: 769920774
Change-Id: I7ecf1ef63d8d6f328e1518382832211db9166fe9

Author: nilayvaish

tcmalloc/huge_page_aware_allocator.h

@@ -131,8 +131,6 @@ class StaticForwarder {
 struct HugePageAwareAllocatorOptions {
   MemoryTag tag;
   HugeRegionUsageOption use_huge_region_more_often = huge_region_option();
-  HugePageFillerDenseTrackerType dense_tracker_type =
-      HugePageFillerDenseTrackerType::kSpansAllocated;
   HugePageFillerSparseTrackerType sparse_tracker_type =
       Parameters::sparse_trackers_coarse_longest_free_range()
           ? HugePageFillerSparseTrackerType::kCoarseLongestFreeRange
@@ -452,8 +450,8 @@ inline HugePageAwareAllocator<Forwarder>::HugePageAwareAllocator(
       unback_(*this),
       unback_without_lock_(*this),
       collapse_(*this),
-      filler_(options.dense_tracker_type, options.sparse_tracker_type, unback_,
-              unback_without_lock_, collapse_),
+      filler_(options.sparse_tracker_type, unback_, unback_without_lock_,
+              collapse_),
       regions_(options.use_huge_region_more_often),
       tracker_allocator_(forwarder_.arena()),
       region_allocator_(forwarder_.arena()),

tcmalloc/huge_page_aware_allocator_fuzz.cc

@@ -87,7 +87,7 @@ void FuzzHPAA(const std::string& s) {
   // [1] - HugeRegionsMode.
   // [2] - HugeCache release time
   // [3:4] - Reserved.
-  // [5] - Dense tracker type
+  // [5] - Reserved.
   // [6] - Sparse tracker type
   // [7:12] - Reserved.
   //
@@ -119,11 +119,6 @@ void FuzzHPAA(const std::string& s) {
 
   const int32_t huge_cache_release_s = std::max<int32_t>(data[2], 1);
 
-  const HugePageFillerDenseTrackerType dense_tracker_type =
-      static_cast<uint8_t>(data[5]) >= 128
-          ? HugePageFillerDenseTrackerType::kLongestFreeRangeAndChunks
-          : HugePageFillerDenseTrackerType::kSpansAllocated;
-
   const HugePageFillerSparseTrackerType sparse_tracker_type =
       static_cast<uint8_t>(data[6]) >= 128
           ? HugePageFillerSparseTrackerType::kExactLongestFreeRange
@@ -138,7 +133,6 @@ void FuzzHPAA(const std::string& s) {
   options.tag = tag;
   options.use_huge_region_more_often = huge_region_option;
   options.huge_cache_time = absl::Seconds(huge_cache_release_s);
-  options.dense_tracker_type = dense_tracker_type;
   options.sparse_tracker_type = sparse_tracker_type;
   HugePageAwareAllocator<FakeStaticForwarderWithUnback> allocator(options);
   auto& forwarder = allocator.forwarder();
@@ -196,9 +190,7 @@ void FuzzHPAA(const std::string& s) {
             // This is an invalid size class, so skip it.
             break;
           }
-          if (dense_tracker_type ==
-                  HugePageFillerDenseTrackerType::kSpansAllocated &&
-              density == AccessDensityPrediction::kDense) {
+          if (density == AccessDensityPrediction::kDense) {
             length = Length(1);
           }
 
@@ -214,8 +206,6 @@ void FuzzHPAA(const std::string& s) {
           SpanAllocInfo alloc_info = {.objects_per_span = num_objects,
                                       .density = density};
           TC_CHECK(
-              dense_tracker_type ==
-                  HugePageFillerDenseTrackerType::kLongestFreeRangeAndChunks ||
               density == AccessDensityPrediction::kSparse ||
               length == Length(1));
           if (use_aligned) {

tcmalloc/huge_page_filler.h

@@ -332,34 +332,23 @@ enum class LFRRequirement : bool {
   kMatchingLFR,
 };
 
-enum class HugePageFillerDenseTrackerType : bool {
-  // Hugepages sorted on longest free range and chunk index. This is currently
-  // the default.
-  kLongestFreeRangeAndChunks,
-  // Hugepages sorted only on number of spans allocated. As we allocate
-  // single-page many-object spans, we do not sort hugepages on longest free
-  // range when this configuration is used.
-  kSpansAllocated,
-};
-
 // This tracks a set of unfilled hugepages, and fulfills allocations
 // with a goal of filling some hugepages as tightly as possible and emptying
 // out the remainder.
 template <class TrackerType>
 class HugePageFiller {
  public:
   explicit HugePageFiller(
-      HugePageFillerDenseTrackerType dense_tracker_type,
       HugePageFillerSparseTrackerType sparse_tracker_type,
       MemoryModifyFunction& unback ABSL_ATTRIBUTE_LIFETIME_BOUND,
       MemoryModifyFunction& unback_without_lock ABSL_ATTRIBUTE_LIFETIME_BOUND,
       MemoryModifyFunction& collapse ABSL_ATTRIBUTE_LIFETIME_BOUND);
-  HugePageFiller(Clock clock, HugePageFillerDenseTrackerType dense_tracker_type,
-                 HugePageFillerSparseTrackerType sparse_tracker_type,
-                 MemoryModifyFunction& unback ABSL_ATTRIBUTE_LIFETIME_BOUND,
-                 MemoryModifyFunction& unback_without_lock
-                     ABSL_ATTRIBUTE_LIFETIME_BOUND,
-                 MemoryModifyFunction& collapse ABSL_ATTRIBUTE_LIFETIME_BOUND);
+
+  HugePageFiller(
+      Clock clock, HugePageFillerSparseTrackerType sparse_tracker_type,
+      MemoryModifyFunction& unback ABSL_ATTRIBUTE_LIFETIME_BOUND,
+      MemoryModifyFunction& unback_without_lock ABSL_ATTRIBUTE_LIFETIME_BOUND,
+      MemoryModifyFunction& collapse ABSL_ATTRIBUTE_LIFETIME_BOUND);
 
   typedef TrackerType Tracker;
 
@@ -580,7 +569,6 @@ class HugePageFiller {
   // n_used_partial_released_ is the number of pages which have been allocated
   // from the hugepages in the set regular_alloc_partial_released.
   Length n_used_partial_released_[AccessDensityPrediction::kPredictionCounts];
-  const HugePageFillerDenseTrackerType dense_tracker_type_;
   const HugePageFillerSparseTrackerType sparse_tracker_type_;
 
   // RemoveFromFillerList pt from the appropriate PageTrackerList.
@@ -797,24 +785,21 @@ inline Length PageTracker::free_pages() const {
 
 template <class TrackerType>
 inline HugePageFiller<TrackerType>::HugePageFiller(
-    HugePageFillerDenseTrackerType dense_tracker_type,
     HugePageFillerSparseTrackerType sparse_tracker_type,
     MemoryModifyFunction& unback, MemoryModifyFunction& unback_without_lock,
     MemoryModifyFunction& collapse)
     : HugePageFiller(Clock{.now = absl::base_internal::CycleClock::Now,
                            .freq = absl::base_internal::CycleClock::Frequency},
-                     dense_tracker_type, sparse_tracker_type, unback,
-                     unback_without_lock, collapse) {}
+                     sparse_tracker_type, unback, unback_without_lock,
+                     collapse) {}
 
 // For testing with mock clock
 template <class TrackerType>
 inline HugePageFiller<TrackerType>::HugePageFiller(
-    Clock clock, HugePageFillerDenseTrackerType dense_tracker_type,
-    HugePageFillerSparseTrackerType sparse_tracker_type,
+    Clock clock, HugePageFillerSparseTrackerType sparse_tracker_type,
     MemoryModifyFunction& unback, MemoryModifyFunction& unback_without_lock,
     MemoryModifyFunction& collapse)
-    : dense_tracker_type_(dense_tracker_type),
-      sparse_tracker_type_(sparse_tracker_type),
+    : sparse_tracker_type_(sparse_tracker_type),
       size_(NHugePages(0)),
       fillerstats_tracker_(clock, absl::Minutes(10), absl::Minutes(5)),
       clock_(clock),
@@ -826,9 +811,7 @@ template <class TrackerType>
 inline typename HugePageFiller<TrackerType>::TryGetResult
 HugePageFiller<TrackerType>::TryGet(Length n, SpanAllocInfo span_alloc_info) {
   TC_ASSERT_GT(n, Length(0));
-  TC_ASSERT(dense_tracker_type_ ==
-                HugePageFillerDenseTrackerType::kLongestFreeRangeAndChunks ||
-            span_alloc_info.density == AccessDensityPrediction::kSparse ||
+  TC_ASSERT(span_alloc_info.density == AccessDensityPrediction::kSparse ||
             n == Length(1));
 
   // How do we choose which hugepage to allocate from (among those with
@@ -2311,14 +2294,6 @@ template <class TrackerType>
 inline size_t HugePageFiller<TrackerType>::DenseListFor(const Length longest,
                                                         const size_t chunk,
                                                         size_t nallocs) const {
-  if (ABSL_PREDICT_TRUE(
-          dense_tracker_type_ ==
-          HugePageFillerDenseTrackerType::kLongestFreeRangeAndChunks)) {
-    TC_ASSERT_LT(longest, kPagesPerHugePage);
-    return longest.raw_num() * kChunks + chunk;
-  }
-  TC_ASSERT(dense_tracker_type_ ==
-            HugePageFillerDenseTrackerType::kSpansAllocated);
   TC_ASSERT_LE(nallocs, kPagesPerHugePage.raw_num());
   // For the dense tracker with hugepages sorted on allocs, the hugepages are
   // placed only in lists that are multiples of kChunks.  The in-between lists

tcmalloc/huge_page_filler_fuzz.cc

@@ -30,6 +30,7 @@
 #include "tcmalloc/common.h"
 #include "tcmalloc/huge_cache.h"
 #include "tcmalloc/huge_page_filler.h"
+#include "tcmalloc/huge_page_subrelease.h"
 #include "tcmalloc/huge_pages.h"
 #include "tcmalloc/internal/allocation_guard.h"
 #include "tcmalloc/internal/clock.h"
@@ -161,7 +162,7 @@ void FuzzFiller(const std::string& s) {
   // We interpret data as a small DSL for exploring the state space of
   // HugePageFiller.
   //
-  // [0] - used for choosing dense tracker type.
+  // [0] - Reserved.
   // [1] - used for choosing sparse tracker type.
   // [2] - (available)
   //
@@ -173,10 +174,6 @@ void FuzzFiller(const std::string& s) {
   //                  For example, this input can provide a Length to
   //                  allocate, or the index of the previous allocation to
   //                  deallocate.
-  const HugePageFillerDenseTrackerType dense_tracker_type =
-      static_cast<uint8_t>(data[0]) >= 128
-          ? HugePageFillerDenseTrackerType::kLongestFreeRangeAndChunks
-          : HugePageFillerDenseTrackerType::kSpansAllocated;
   const HugePageFillerSparseTrackerType sparse_tracker_type =
       static_cast<uint8_t>(data[1]) >= 128
           ? HugePageFillerSparseTrackerType::kExactLongestFreeRange
@@ -185,8 +182,8 @@ void FuzzFiller(const std::string& s) {
   size -= kInitBytes;
 
   HugePageFiller<PageTracker> filler(Clock{.now = mock_clock, .freq = freq},
-                                     dense_tracker_type, sparse_tracker_type,
-                                     unback, unback, collapse);
+                                     sparse_tracker_type, unback, unback,
+                                     collapse);
 
   std::vector<PageTracker*> trackers;
   absl::flat_hash_map<PageTracker*, std::vector<Range>> allocs;
@@ -224,9 +221,7 @@ void FuzzFiller(const std::string& s) {
           num_objects = 1;
           density = AccessDensityPrediction::kSparse;
         }
-        if (dense_tracker_type ==
-                HugePageFillerDenseTrackerType::kSpansAllocated &&
-            density == AccessDensityPrediction::kDense) {
+        if (density == AccessDensityPrediction::kDense) {
           n = Length(1);
         }