grpc 1.48.0 → 1.50.0

data/src/core/lib/event_engine/{iomgr_engine/iomgr_engine.cc → posix_engine/posix_engine.cc}

@@ -13,49 +13,34 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/event_engine/iomgr_engine/iomgr_engine.h"
+#include "src/core/lib/event_engine/posix_engine/posix_engine.h"
 
-#include <algorithm>
 #include <string>
 #include <utility>
 
 #include "absl/container/flat_hash_set.h"
-#include "absl/strings/str_cat.h"
+#include "absl/functional/any_invocable.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/event_engine/iomgr_engine/timer.h"
+#include "src/core/lib/event_engine/executor/threaded_executor.h"
+#include "src/core/lib/event_engine/posix_engine/timer.h"
 #include "src/core/lib/event_engine/trace.h"
-#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/event_engine/utils.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-namespace {
-
-std::string HandleToString(EventEngine::TaskHandle handle) {
-  return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
-}
-
-}  // namespace
-
-grpc_core::Timestamp IomgrEventEngine::ToTimestamp(EventEngine::Duration when) {
-  return timer_manager_.Now() +
-         std::max(grpc_core::Duration::Milliseconds(1),
-                  grpc_core::Duration::NanosecondsRoundUp(when.count())) +
-         grpc_core::Duration::Milliseconds(1);
-}
-
-struct IomgrEventEngine::ClosureData final : public EventEngine::Closure {
-  std::function<void()> cb;
-  iomgr_engine::Timer timer;
-  IomgrEventEngine* engine;
+struct PosixEventEngine::ClosureData final : public EventEngine::Closure {
+  absl::AnyInvocable<void()> cb;
+  posix_engine::Timer timer;
+  PosixEventEngine* engine;
   EventEngine::TaskHandle handle;
 
   void Run() override {
-    GRPC_EVENT_ENGINE_TRACE("IomgrEventEngine:%p executing callback:%s", engine,
+    GRPC_EVENT_ENGINE_TRACE("PosixEventEngine:%p executing callback:%s", engine,
                             HandleToString(handle).c_str());
     {
       grpc_core::MutexLock lock(&engine->mu_);
@@ -66,14 +51,12 @@ struct IomgrEventEngine::ClosureData final : public EventEngine::Closure {
   }
 };
 
-IomgrEventEngine::IomgrEventEngine() {}
-
-IomgrEventEngine::~IomgrEventEngine() {
+PosixEventEngine::~PosixEventEngine() {
   grpc_core::MutexLock lock(&mu_);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
     for (auto handle : known_handles_) {
       gpr_log(GPR_ERROR,
-              "(event_engine) IomgrEventEngine:%p uncleared TaskHandle at "
+              "(event_engine) PosixEventEngine:%p uncleared TaskHandle at "
               "shutdown:%s",
               this, HandleToString(handle).c_str());
     }
@@ -81,7 +64,7 @@ IomgrEventEngine::~IomgrEventEngine() {
   GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
 }
 
-bool IomgrEventEngine::Cancel(EventEngine::TaskHandle handle) {
+bool PosixEventEngine::Cancel(EventEngine::TaskHandle handle) {
   grpc_core::MutexLock lock(&mu_);
   if (!known_handles_.contains(handle)) return false;
   auto* cd = reinterpret_cast<ClosureData*>(handle.keys[0]);
@@ -91,27 +74,27 @@ bool IomgrEventEngine::Cancel(EventEngine::TaskHandle handle) {
   return r;
 }
 
-EventEngine::TaskHandle IomgrEventEngine::RunAfter(
-    Duration when, std::function<void()> closure) {
+EventEngine::TaskHandle PosixEventEngine::RunAfter(
+    Duration when, absl::AnyInvocable<void()> closure) {
   return RunAfterInternal(when, std::move(closure));
 }
 
-EventEngine::TaskHandle IomgrEventEngine::RunAfter(
+EventEngine::TaskHandle PosixEventEngine::RunAfter(
     Duration when, EventEngine::Closure* closure) {
   return RunAfterInternal(when, [closure]() { closure->Run(); });
 }
 
-void IomgrEventEngine::Run(std::function<void()> closure) {
-  thread_pool_.Add(closure);
+void PosixEventEngine::Run(absl::AnyInvocable<void()> closure) {
+  executor_.Run(std::move(closure));
 }
 
-void IomgrEventEngine::Run(EventEngine::Closure* closure) {
-  thread_pool_.Add([closure]() { closure->Run(); });
+void PosixEventEngine::Run(EventEngine::Closure* closure) {
+  executor_.Run(closure);
 }
 
-EventEngine::TaskHandle IomgrEventEngine::RunAfterInternal(
-    Duration when, std::function<void()> cb) {
-  auto when_ts = ToTimestamp(when);
+EventEngine::TaskHandle PosixEventEngine::RunAfterInternal(
+    Duration when, absl::AnyInvocable<void()> cb) {
+  auto when_ts = ToTimestamp(timer_manager_.Now(), when);
   auto* cd = new ClosureData;
   cd->cb = std::move(cb);
   cd->engine = this;
@@ -120,26 +103,26 @@ EventEngine::TaskHandle IomgrEventEngine::RunAfterInternal(
   grpc_core::MutexLock lock(&mu_);
   known_handles_.insert(handle);
   cd->handle = handle;
-  GRPC_EVENT_ENGINE_TRACE("IomgrEventEngine:%p scheduling callback:%s", this,
+  GRPC_EVENT_ENGINE_TRACE("PosixEventEngine:%p scheduling callback:%s", this,
                           HandleToString(handle).c_str());
   timer_manager_.TimerInit(&cd->timer, when_ts, cd);
   return handle;
 }
 
-std::unique_ptr<EventEngine::DNSResolver> IomgrEventEngine::GetDNSResolver(
+std::unique_ptr<EventEngine::DNSResolver> PosixEventEngine::GetDNSResolver(
     EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
   GPR_ASSERT(false && "unimplemented");
 }
 
-bool IomgrEventEngine::IsWorkerThread() {
+bool PosixEventEngine::IsWorkerThread() {
   GPR_ASSERT(false && "unimplemented");
 }
 
-bool IomgrEventEngine::CancelConnect(EventEngine::ConnectionHandle /*handle*/) {
+bool PosixEventEngine::CancelConnect(EventEngine::ConnectionHandle /*handle*/) {
   GPR_ASSERT(false && "unimplemented");
 }
 
-EventEngine::ConnectionHandle IomgrEventEngine::Connect(
+EventEngine::ConnectionHandle PosixEventEngine::Connect(
     OnConnectCallback /*on_connect*/, const ResolvedAddress& /*addr*/,
     const EndpointConfig& /*args*/, MemoryAllocator /*memory_allocator*/,
     Duration /*deadline*/) {
@@ -147,9 +130,9 @@ EventEngine::ConnectionHandle IomgrEventEngine::Connect(
 }
 
 absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
-IomgrEventEngine::CreateListener(
+PosixEventEngine::CreateListener(
     Listener::AcceptCallback /*on_accept*/,
-    std::function<void(absl::Status)> /*on_shutdown*/,
+    absl::AnyInvocable<void(absl::Status)> /*on_shutdown*/,
     const EndpointConfig& /*config*/,
     std::unique_ptr<MemoryAllocatorFactory> /*memory_allocator_factory*/) {
   GPR_ASSERT(false && "unimplemented");

data/src/core/lib/event_engine/{iomgr_engine/iomgr_engine.h → posix_engine/posix_engine.h}

@@ -11,17 +11,17 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_IOMGR_ENGINE_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_IOMGR_ENGINE_H
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_H
 #include <grpc/support/port_platform.h>
 
 #include <stdint.h>
 
 #include <atomic>
-#include <functional>
 #include <memory>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -31,38 +31,37 @@
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
 
+#include "src/core/lib/event_engine/executor/threaded_executor.h"
 #include "src/core/lib/event_engine/handle_containers.h"
-#include "src/core/lib/event_engine/iomgr_engine/thread_pool.h"
-#include "src/core/lib/event_engine/iomgr_engine/timer_manager.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/gprpp/time.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-// An iomgr-based EventEngine implementation.
+// An iomgr-based Posix EventEngine implementation.
 // All methods require an ExecCtx to already exist on the thread's stack.
-class IomgrEventEngine final : public EventEngine {
+class PosixEventEngine final : public EventEngine {
  public:
-  class IomgrEndpoint : public EventEngine::Endpoint {
+  class PosixEndpoint : public EventEngine::Endpoint {
    public:
-    ~IomgrEndpoint() override;
-    void Read(std::function<void(absl::Status)> on_read, SliceBuffer* buffer,
-              const ReadArgs* args) override;
-    void Write(std::function<void(absl::Status)> on_writable, SliceBuffer* data,
-               const WriteArgs* args) override;
+    ~PosixEndpoint() override;
+    void Read(absl::AnyInvocable<void(absl::Status)> on_read,
+              SliceBuffer* buffer, const ReadArgs* args) override;
+    void Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+               SliceBuffer* data, const WriteArgs* args) override;
     const ResolvedAddress& GetPeerAddress() const override;
     const ResolvedAddress& GetLocalAddress() const override;
   };
-  class IomgrListener : public EventEngine::Listener {
+  class PosixListener : public EventEngine::Listener {
    public:
-    ~IomgrListener() override;
+    ~PosixListener() override;
     absl::StatusOr<int> Bind(const ResolvedAddress& addr) override;
     absl::Status Start() override;
   };
-  class IomgrDNSResolver : public EventEngine::DNSResolver {
+  class PosixDNSResolver : public EventEngine::DNSResolver {
    public:
-    ~IomgrDNSResolver() override;
+    ~PosixDNSResolver() override;
     LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
                                     absl::string_view name,
                                     absl::string_view default_port,
@@ -76,12 +75,12 @@ class IomgrEventEngine final : public EventEngine {
     bool CancelLookup(LookupTaskHandle handle) override;
   };
 
-  IomgrEventEngine();
-  ~IomgrEventEngine() override;
+  PosixEventEngine() = default;
+  ~PosixEventEngine() override;
 
   absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
       Listener::AcceptCallback on_accept,
-      std::function<void(absl::Status)> on_shutdown,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
       const EndpointConfig& config,
       std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
       override;
@@ -97,19 +96,19 @@ class IomgrEventEngine final : public EventEngine {
   std::unique_ptr<DNSResolver> GetDNSResolver(
       const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
-  void Run(std::function<void()> closure) override;
+  void Run(absl::AnyInvocable<void()> closure) override;
   TaskHandle RunAfter(Duration when, Closure* closure) override;
-  TaskHandle RunAfter(Duration when, std::function<void()> closure) override;
+  TaskHandle RunAfter(Duration when,
+                      absl::AnyInvocable<void()> closure) override;
   bool Cancel(TaskHandle handle) override;
 
  private:
   struct ClosureData;
   EventEngine::TaskHandle RunAfterInternal(Duration when,
-                                           std::function<void()> cb);
-  grpc_core::Timestamp ToTimestamp(EventEngine::Duration when);
+                                           absl::AnyInvocable<void()> cb);
 
-  iomgr_engine::TimerManager timer_manager_;
-  iomgr_engine::ThreadPool thread_pool_{2};
+  posix_engine::TimerManager timer_manager_;
+  ThreadedExecutor executor_{2};
 
   grpc_core::Mutex mu_;
   TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
@@ -119,4 +118,4 @@ class IomgrEventEngine final : public EventEngine {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_IOMGR_ENGINE_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_H

data/src/core/lib/event_engine/{iomgr_engine → posix_engine}/timer.cc

@@ -18,22 +18,21 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/event_engine/iomgr_engine/timer.h"
+#include "src/core/lib/event_engine/posix_engine/timer.h"
 
 #include <algorithm>
 #include <atomic>
 #include <limits>
-#include <type_traits>
 #include <utility>
 
 #include <grpc/support/cpu.h>
 
-#include "src/core/lib/event_engine/iomgr_engine/timer_heap.h"
+#include "src/core/lib/event_engine/posix_engine/timer_heap.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/time.h"
 
 namespace grpc_event_engine {
-namespace iomgr_engine {
+namespace posix_engine {
 
 static const size_t kInvalidHeapIndex = std::numeric_limits<size_t>::max();
 static const double kAddDeadlineScale = 0.33;
@@ -308,5 +307,5 @@ TimerList::TimerCheck(grpc_core::Timestamp* next) {
   return std::move(run);
 }
 
-}  // namespace iomgr_engine
+}  // namespace posix_engine
 }  // namespace grpc_event_engine

data/src/core/lib/event_engine/{iomgr_engine → posix_engine}/timer.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_H
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -33,13 +33,13 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/iomgr_engine/time_averaged_stats.h"
-#include "src/core/lib/event_engine/iomgr_engine/timer_heap.h"
+#include "src/core/lib/event_engine/posix_engine/timer_heap.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/time_averaged_stats.h"
 
 namespace grpc_event_engine {
-namespace iomgr_engine {
+namespace posix_engine {
 
 struct Timer {
   int64_t deadline;
@@ -151,7 +151,7 @@ class TimerList {
         ABSL_LOCKS_EXCLUDED(mu);
 
     grpc_core::Mutex mu;
-    TimeAveragedStats stats ABSL_GUARDED_BY(mu);
+    grpc_core::TimeAveragedStats stats ABSL_GUARDED_BY(mu);
     /* All and only timers with deadlines < this will be in the heap. */
     grpc_core::Timestamp queue_deadline_cap ABSL_GUARDED_BY(mu);
     /* The deadline of the next timer due in this shard. */
@@ -187,7 +187,7 @@ class TimerList {
   const std::unique_ptr<Shard*[]> shard_queue_ ABSL_GUARDED_BY(mu_);
 };
 
-}  // namespace iomgr_engine
+}  // namespace posix_engine
 }  // namespace grpc_event_engine
 
-#endif /* GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_H */
+#endif /* GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H */

data/src/core/lib/event_engine/{iomgr_engine → posix_engine}/timer_heap.cc

@@ -18,16 +18,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/event_engine/iomgr_engine/timer_heap.h"
+#include "src/core/lib/event_engine/posix_engine/timer_heap.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
-#include "src/core/lib/event_engine/iomgr_engine/timer.h"
+#include "src/core/lib/event_engine/posix_engine/timer.h"
 
 namespace grpc_event_engine {
-namespace iomgr_engine {
+namespace posix_engine {
 
 /* Adjusts a heap so as to move a hole at position i closer to the root,
    until a suitable position is found for element t. Then, copies t into that
@@ -103,5 +103,5 @@ Timer* TimerHeap::Top() { return timers_[0]; }
 
 void TimerHeap::Pop() { Remove(Top()); }
 
-}  // namespace iomgr_engine
+}  // namespace posix_engine
 }  // namespace grpc_event_engine

data/src/core/lib/event_engine/{iomgr_engine → posix_engine}/timer_heap.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_HEAP_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_HEAP_H
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,7 +25,7 @@
 #include <vector>
 
 namespace grpc_event_engine {
-namespace iomgr_engine {
+namespace posix_engine {
 
 struct Timer;
 
@@ -50,7 +50,7 @@ class TimerHeap {
   std::vector<Timer*> timers_;
 };
 
-}  // namespace iomgr_engine
+}  // namespace posix_engine
 }  // namespace grpc_event_engine
 
-#endif /* GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_HEAP_H */
+#endif /* GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H */

data/src/core/lib/event_engine/{iomgr_engine → posix_engine}/timer_manager.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/event_engine/iomgr_engine/timer_manager.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 
 #include <algorithm>
 #include <memory>
@@ -32,10 +32,16 @@
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/thd.h"
 
+static GPR_THREAD_LOCAL(bool) g_timer_thread;
+
 namespace grpc_event_engine {
-namespace iomgr_engine {
+namespace posix_engine {
+
+grpc_core::DebugOnlyTraceFlag grpc_event_engine_timer_trace(false, "timer");
 
 namespace {
 class ThreadCollector {
@@ -62,8 +68,9 @@ void TimerManager::StartThread() {
   ++thread_count_;
   auto* thread = new RunThreadArgs();
   thread->self = this;
-  thread->thread =
-      grpc_core::Thread("timer_manager", &TimerManager::RunThread, thread);
+  thread->thread = grpc_core::Thread(
+      "timer_manager", &TimerManager::RunThread, thread, nullptr,
+      grpc_core::Thread::Options().set_tracked(false));
   thread->thread.Start();
 }
 
@@ -73,19 +80,21 @@ void TimerManager::RunSomeTimers(
   ThreadCollector collector;
   {
     grpc_core::MutexLock lock(&mu_);
+    if (shutdown_ || forking_) return;
     // remove a waiter from the pool, and start another thread if necessary
     --waiter_count_;
     if (waiter_count_ == 0) {
       // The number of timer threads is always increasing until all the threads
-      // are stopped. In rare cases, if a large number of timers fire
-      // simultaneously, we may end up using a large number of threads.
+      // are stopped, with the exception that all threads are shut down on fork
+      // events. In rare cases, if a large number of timers fire simultaneously,
+      // we may end up using a large number of threads.
       // TODO(ctiller): We could avoid this by exiting threads in WaitUntil().
       StartThread();
     } else {
       // if there's no thread waiting with a timeout, kick an existing untimed
       // waiter so that the next deadline is not missed
       if (!has_timed_waiter_) {
-        cv_.Signal();
+        cv_wait_.Signal();
       }
     }
   }
@@ -106,9 +115,8 @@ void TimerManager::RunSomeTimers(
 bool TimerManager::WaitUntil(grpc_core::Timestamp next) {
   grpc_core::MutexLock lock(&mu_);
 
-  if (shutdown_) {
-    return false;
-  }
+  if (shutdown_) return false;
+  if (forking_) return false;
 
   // TODO(ctiller): if there are too many waiting threads, this would be a good
   // place to exit the current thread.
@@ -149,8 +157,8 @@ bool TimerManager::WaitUntil(grpc_core::Timestamp next) {
       }
     }
 
-    cv_.WaitWithTimeout(&mu_,
-                        absl::Milliseconds((next - host_.Now()).millis()));
+    cv_wait_.WaitWithTimeout(&mu_,
+                             absl::Milliseconds((next - host_.Now()).millis()));
 
     // if this was the timed waiter, then we need to check timers, and flag
     // that there's now no timed waiter... we'll look for a replacement if
@@ -194,16 +202,29 @@ void TimerManager::MainLoop() {
 }
 
 void TimerManager::RunThread(void* arg) {
+  g_timer_thread = true;
   std::unique_ptr<RunThreadArgs> thread(static_cast<RunThreadArgs*>(arg));
-  thread->self->MainLoop();
-  {
-    grpc_core::MutexLock lock(&thread->self->mu_);
-    thread->self->thread_count_--;
-    thread->self->completed_threads_.push_back(std::move(thread->thread));
+  if (grpc_event_engine_timer_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "TimerManager::%p starting thread::%p", thread->self,
+            &thread->thread);
   }
-  thread->self->cv_.Signal();
+  thread->self->Run(std::move(thread->thread));
+  if (grpc_event_engine_timer_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "TimerManager::%p thread::%p finished", thread->self,
+            &thread->thread);
+  }
+}
+
+void TimerManager::Run(grpc_core::Thread thread) {
+  MainLoop();
+  grpc_core::MutexLock lock(&mu_);
+  completed_threads_.push_back(std::move(thread));
+  thread_count_--;
+  if (thread_count_ == 0) cv_threadcount_.Signal();
 }
 
+bool TimerManager::IsTimerManagerThread() { return g_timer_thread; }
+
 TimerManager::TimerManager() : host_(this) {
   timer_list_ = absl::make_unique<TimerList>(&host_);
   grpc_core::MutexLock lock(&mu_);
@@ -225,17 +246,23 @@ bool TimerManager::TimerCancel(Timer* timer) {
 }
 
 TimerManager::~TimerManager() {
-  {
-    grpc_core::MutexLock lock(&mu_);
-    shutdown_ = true;
-    cv_.SignalAll();
+  if (grpc_event_engine_timer_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "TimerManager::%p shutting down", this);
   }
-  while (true) {
-    ThreadCollector collector;
-    grpc_core::MutexLock lock(&mu_);
-    collector.Collect(std::move(completed_threads_));
-    if (thread_count_ == 0) break;
-    cv_.Wait(&mu_);
+  ThreadCollector collector;
+  grpc_core::MutexLock lock(&mu_);
+  shutdown_ = true;
+  cv_wait_.SignalAll();
+  while (thread_count_ > 0) {
+    cv_threadcount_.Wait(&mu_);
+    if (grpc_event_engine_timer_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "TimerManager::%p waiting for %zu threads to finish",
+              this, thread_count_);
+    }
+  }
+  collector.Collect(std::move(completed_threads_));
+  if (grpc_event_engine_timer_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "TimerManager::%p shutdown complete", this);
   }
 }
 
@@ -247,8 +274,38 @@ void TimerManager::Kick() {
   timed_waiter_deadline_ = grpc_core::Timestamp::InfFuture();
   ++timed_waiter_generation_;
   kicked_ = true;
-  cv_.Signal();
+  cv_wait_.Signal();
+}
+
+void TimerManager::PrepareFork() {
+  ThreadCollector collector;
+  grpc_core::MutexLock lock(&mu_);
+  forking_ = true;
+  prefork_thread_count_ = thread_count_;
+  cv_wait_.SignalAll();
+  while (thread_count_ > 0) {
+    cv_threadcount_.Wait(&mu_);
+  }
+  collector.Collect(std::move(completed_threads_));
+}
+
+void TimerManager::PostforkParent() {
+  grpc_core::MutexLock lock(&mu_);
+  for (int i = 0; i < prefork_thread_count_; i++) {
+    StartThread();
+  }
+  prefork_thread_count_ = 0;
+  forking_ = false;
+}
+
+void TimerManager::PostforkChild() {
+  grpc_core::MutexLock lock(&mu_);
+  for (int i = 0; i < prefork_thread_count_; i++) {
+    StartThread();
+  }
+  prefork_thread_count_ = 0;
+  forking_ = false;
 }
 
-}  // namespace iomgr_engine
+}  // namespace posix_engine
 }  // namespace grpc_event_engine