Revert: Add a malloc extension to get estimated allocated size for cold allocations

PiperOrigin-RevId: 818709718
Change-Id: Ibb36f3a38df7d828a98ed62f4c8c9e3514728794

Author: ckennelly

tcmalloc/internal_malloc_extension.h

@@ -128,8 +128,6 @@ MallocExtension_Internal_ReleaseMemoryToSystem(size_t bytes);
 ABSL_ATTRIBUTE_WEAK void MallocExtension_Internal_SetMemoryLimit(
     size_t limit, tcmalloc::MallocExtension::LimitKind limit_kind);
 
-ABSL_ATTRIBUTE_WEAK size_t MallocExtension_Internal_GetEstimatedAllocatedSize(
-    size_t bytes, tcmalloc::hot_cold_t hot_cold);
 ABSL_ATTRIBUTE_WEAK size_t
 MallocExtension_Internal_GetAllocatedSize(const void* ptr);
 ABSL_ATTRIBUTE_WEAK void MallocExtension_Internal_MarkThreadBusy();

tcmalloc/malloc_extension.cc

@@ -662,17 +662,6 @@ std::optional<size_t> MallocExtension::GetNumericProperty(
   return std::nullopt;
 }
 
-size_t MallocExtension::GetEstimatedAllocatedSize(size_t size,
-                                                  hot_cold_t hot_cold) {
-#if ABSL_INTERNAL_HAVE_WEAK_MALLOCEXTENSION_STUBS
-  if (MallocExtension_Internal_GetEstimatedAllocatedSize != nullptr) {
-    return MallocExtension_Internal_GetEstimatedAllocatedSize(size, hot_cold);
-  }
-#endif
-  // Fall-through to assuming that the hot/cold hint doesn't affect the
-  return nallocx(size, 0);
-}
-
 size_t MallocExtension::GetEstimatedAllocatedSize(size_t size) {
   return nallocx(size, 0);
 }

tcmalloc/malloc_extension.h

@@ -578,12 +578,6 @@ class MallocExtension final {
   // reserve more bytes, but will never reserve fewer.
   [[nodiscard]] static size_t GetEstimatedAllocatedSize(size_t size);
 
-  // Returns the estimated number of bytes that will be allocated for a request
-  // of "size" bytes.  This is an estimate: an allocation of "size" bytes may
-  // reserve more bytes, but will never reserve fewer.
-  static size_t GetEstimatedAllocatedSize(size_t size,
-                                          tcmalloc::hot_cold_t hot_cold);
-
   // Returns the actual number N of bytes reserved by tcmalloc for the pointer
   // p.  This number may be equal to or greater than the number of bytes
   // requested when p was allocated.

tcmalloc/tcmalloc.cc

@@ -352,13 +352,12 @@ extern "C" size_t MallocExtension_Internal_ReleaseMemoryToSystem(
 // stack spills. ABSL_ATTRIBUTE_ALWAYS_INLINE does not work on
 // size_class_with_alignment, compiler barks that it can't inline the function
 // somewhere.
-static ABSL_ATTRIBUTE_NOINLINE size_t nallocx_slow(size_t size, int flags,
-                                                   hot_cold_t hot_cold) {
+static ABSL_ATTRIBUTE_NOINLINE size_t nallocx_slow(size_t size, int flags) {
   tc_globals.InitIfNecessary();
   size_t align = static_cast<size_t>(1ull << (flags & 0x3f));
   size_t size_class;
   if (ABSL_PREDICT_TRUE(tc_globals.sizemap().GetSizeClass(
-          CppPolicy().AlignAs(align).AccessAs(hot_cold), size, &size_class))) {
+          CppPolicy().AlignAs(align), size, &size_class))) {
     TC_ASSERT_NE(size_class, 0);
     return tc_globals.sizemap().class_to_size(size_class);
   } else {
@@ -373,7 +372,7 @@ static ABSL_ATTRIBUTE_NOINLINE size_t nallocx_slow(size_t size, int flags,
 // http://www.unix.com/man-page/freebsd/3/nallocx/
 extern "C" size_t nallocx(size_t size, int flags) noexcept {
   if (ABSL_PREDICT_FALSE(!tc_globals.IsInited() || flags != 0)) {
-    return nallocx_slow(size, flags, hot_cold_t{255});
+    return nallocx_slow(size, flags);
   }
   size_t size_class;
   if (ABSL_PREDICT_TRUE(
@@ -385,11 +384,6 @@ extern "C" size_t nallocx(size_t size, int flags) noexcept {
   }
 }
 
-extern "C" size_t MallocExtension_Internal_GetEstimatedAllocatedSize(
-    size_t bytes, tcmalloc::hot_cold_t hot_cold) {
-  return nallocx_slow(bytes, 0, hot_cold);
-}
-
 extern "C" MallocExtension::Ownership MallocExtension_Internal_GetOwnership(
     const void* ptr) {
   return GetOwnership(ptr);

tcmalloc/testing/tcmalloc_test.cc

@@ -799,23 +799,6 @@ TEST(TCMallocTest, nallocx_alignment) {
   }
 }
 
-TEST(TCMallocTest, GetEstimatedAllocatedSizeHotCold) {
-  // Guarded allocations may have a smaller allocated size than nallocx
-  // predicts.  So we disable guarded allocations.
-  ScopedGuardedSamplingInterval gs(-1);
-  for (size_t size = 0; size <= kMaxTestAllocSize; size += 17) {
-    for (hot_cold_t hot_cold : {hot_cold_t{0}, hot_cold_t{255}}) {
-      size_t rounded =
-          MallocExtension::GetEstimatedAllocatedSize(size, hot_cold);
-      ASSERT_GE(rounded, size);
-      auto [ptr, allocated_size] =
-          __size_returning_new_hot_cold(size, hot_cold);
-      ASSERT_EQ(rounded, allocated_size);
-      sized_delete(ptr, size);
-    }
-  }
-}
-
 TEST(TCMallocTest, sdallocx) {
   for (size_t size = 0; size <= 4096; size += 7) {
     void* ptr = malloc(size);