3 files changed, 0 insertions, 84 deletions

diff --git a/absl/synchronization/internal/per_thread_sem.cc b/absl/synchronization/internal/per_thread_sem.cc
index af87222816d5..caa2baf64bd3 100644
--- a/absl/synchronization/internal/per_thread_sem.cc
+++ b/absl/synchronization/internal/per_thread_sem.cc
@@ -21,7 +21,6 @@
 #include <atomic>
 
 #include "absl/base/attributes.h"
-#include "absl/base/internal/malloc_extension.h"
 #include "absl/base/internal/thread_identity.h"
 #include "absl/synchronization/internal/waiter.h"
 
@@ -90,12 +89,6 @@ ABSL_ATTRIBUTE_WEAK bool AbslInternalPerThreadSemWait(
   if (identity->blocked_count_ptr != nullptr) {
     identity->blocked_count_ptr->fetch_sub(1, std::memory_order_relaxed);
   }
-
-  if (identity->is_idle.load(std::memory_order_relaxed)) {
-    // We became idle during the wait; become non-idle again so that
-    // performance of deallocations done from now on does not suffer.
-    absl::base_internal::MallocExtension::instance()->MarkThreadBusy();
-  }
   identity->is_idle.store(false, std::memory_order_relaxed);
   identity->wait_start.store(0, std::memory_order_relaxed);
   return !timeout;
diff --git a/absl/synchronization/internal/per_thread_sem_test.cc b/absl/synchronization/internal/per_thread_sem_test.cc
index 61296cfca502..2b52ea76ab0e 100644
--- a/absl/synchronization/internal/per_thread_sem_test.cc
+++ b/absl/synchronization/internal/per_thread_sem_test.cc
@@ -24,7 +24,6 @@
 
 #include "gtest/gtest.h"
 #include "absl/base/internal/cycleclock.h"
-#include "absl/base/internal/malloc_extension.h"
 #include "absl/base/internal/thread_identity.h"
 #include "absl/strings/str_cat.h"
 #include "absl/time/clock.h"
@@ -167,79 +166,6 @@ TEST_F(PerThreadSemTest, Timeouts) {
   EXPECT_TRUE(Wait(negative_timeout));
 }
 
-// Test that idle threads properly register themselves as such with malloc.
-TEST_F(PerThreadSemTest, Idle) {
-  // We can't use gmock because it might use synch calls.  So we do it
-  // by hand, messily.  I don't bother hitting every one of the
-  // MallocExtension calls because most of them won't get made
-  // anyway--if they do we can add them.
-  class MockMallocExtension : public base_internal::MallocExtension {
-   public:
-    MockMallocExtension(base_internal::MallocExtension *real,
-                        base_internal::ThreadIdentity *id,
-                        std::atomic<int> *idles, std::atomic<int> *busies)
-        : real_(real), id_(id), idles_(idles), busies_(busies) {}
-    void MarkThreadIdle() override {
-      if (base_internal::CurrentThreadIdentityIfPresent() != id_) {
-        return;
-      }
-      idles_->fetch_add(1, std::memory_order_relaxed);
-    }
-
-    void MarkThreadBusy() override {
-      if (base_internal::CurrentThreadIdentityIfPresent() != id_) {
-        return;
-      }
-      busies_->fetch_add(1, std::memory_order_relaxed);
-    }
-    size_t GetAllocatedSize(const void* p) override {
-      return real_->GetAllocatedSize(p);
-    }
-
-   private:
-    MallocExtension *real_;
-    base_internal::ThreadIdentity *id_;
-    std::atomic<int>* idles_;
-    std::atomic<int>* busies_;
-  };
-
-  base_internal::ThreadIdentity *id = GetOrCreateCurrentThreadIdentity();
-  std::atomic<int> idles(0);
-  std::atomic<int> busies(0);
-  base_internal::MallocExtension *old =
-      base_internal::MallocExtension::instance();
-  MockMallocExtension mock(old, id, &idles, &busies);
-  base_internal::MallocExtension::Register(&mock);
-  std::atomic<int> sync(0);
-
-  std::thread t([id, &idles, &sync]() {
-    // Wait for the main thread to begin the wait process
-    while (0 == sync.load(std::memory_order_relaxed)) {
-      SleepFor(absl::Milliseconds(1));
-    }
-    // Wait for main thread to become idle, then wake it
-    // pretend time is passing--enough of these should cause an idling.
-    for (int i = 0; i < 100; ++i) {
-      Tick(id);
-    }
-    while (0 == idles.load(std::memory_order_relaxed)) {
-      // Keep ticking, just in case.
-      Tick(id);
-      SleepFor(absl::Milliseconds(1));
-    }
-    Post(id);
-  });
-
-  idles.store(0, std::memory_order_relaxed);  // In case we slept earlier.
-  sync.store(1, std::memory_order_relaxed);
-  Wait(KernelTimeout::Never());
-
-  // t will wake us once we become idle.
-  EXPECT_LT(0, busies.load(std::memory_order_relaxed));
-  t.join();
-  base_internal::MallocExtension::Register(old);
-}
-
 }  // namespace
 
 }  // namespace synchronization_internal
diff --git a/absl/synchronization/internal/waiter.cc b/absl/synchronization/internal/waiter.cc
index db1b54f6d039..768c52085cd3 100644
--- a/absl/synchronization/internal/waiter.cc
+++ b/absl/synchronization/internal/waiter.cc
@@ -40,8 +40,6 @@
 #include <atomic>
 #include <cassert>
 #include <cstdint>
-
-#include "absl/base/internal/malloc_extension.h"
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/thread_identity.h"
 #include "absl/base/optimization.h"
@@ -59,7 +57,6 @@ static void MaybeBecomeIdle() {
   const int wait_start = identity->wait_start.load(std::memory_order_relaxed);
   if (!is_idle && ticker - wait_start > Waiter::kIdlePeriods) {
     identity->is_idle.store(true, std::memory_order_relaxed);
-    base_internal::MallocExtension::instance()->MarkThreadIdle();
   }
 }