Stop the pool optimizer in stopWorkers()

cachelib/allocator/CacheAllocator.h

@@ -6359,6 +6359,7 @@ folly::IOBufQueue CacheAllocator<CacheTrait>::saveStateToIOBuf() {
 template <typename CacheTrait>
 bool CacheAllocator<CacheTrait>::stopWorkers(std::chrono::seconds timeout) {
   bool success = true;
+  success &= stopPoolOptimizer(timeout);
   success &= stopPoolRebalancer(timeout);
   success &= stopPoolResizer(timeout);
   success &= stopMemMonitor(timeout);

cachelib/allocator/tests/SimplePoolOptimizationTest.cpp

@@ -29,6 +29,10 @@ TYPED_TEST(SimplePoolOptimizationTest, PoolOptimizerBasic) {
   this->testPoolOptimizerBasic();
 }
 
+TYPED_TEST(SimplePoolOptimizationTest, StopWorkersStopsPoolOptimizer) {
+  this->testStopWorkersStopsPoolOptimizer();
+}
+
 } // namespace tests
 } // namespace cachelib
 } // namespace facebook

cachelib/allocator/tests/SimplePoolOptimizationTest.h

@@ -19,7 +19,10 @@
 #include <folly/Random.h>
 #include <gtest/gtest.h>
 
+#include <atomic>
+#include <chrono>
 #include <future>
+#include <thread>
 
 #include "cachelib/allocator/CCacheAllocator.h"
 #include "cachelib/allocator/PoolOptimizer.h"
@@ -85,6 +88,34 @@ struct SimplePoolOptimizeStrategy : public PoolOptimizeStrategy {
 template <typename AllocatorT>
 class SimplePoolOptimizationTest : public testing::Test {
  public:
+  void testStopWorkersStopsPoolOptimizer() {
+    struct CountingStrategy : public PoolOptimizeStrategy {
+      std::atomic<int> calls{0};
+
+     protected:
+      PoolOptimizeContext pickVictimAndReceiverRegularPoolsImpl(
+          const CacheBase&) override {
+        ++calls;
+        return kNoOpContext;
+      }
+    };
+    auto strategy = std::make_shared<CountingStrategy>();
+    typename AllocatorT::Config config;
+    config.setCacheSize(30 * Slab::kSize);
+    config.enablePoolOptimizer(strategy, std::chrono::seconds{1},
+                               std::chrono::seconds{1}, 1);
+    AllocatorT alloc(config);
+    for (int i = 0; i < 100 && strategy->calls == 0; ++i) {
+      std::this_thread::sleep_for(std::chrono::milliseconds{100});
+    }
+    ASSERT_GT(strategy->calls.load(), 0);
+
+    ASSERT_TRUE(alloc.stopWorkers());
+    const int calls = strategy->calls.load();
+    std::this_thread::sleep_for(std::chrono::seconds{2});
+    EXPECT_EQ(calls, strategy->calls.load());
+  }
+
   void testPoolOptimizerBasic() {
     typename AllocatorT::Config config;
     config.setCacheSize(30 * Slab::kSize);