grpc 1.59.0 → 1.60.0.pre1

data/src/core/lib/event_engine/posix_engine/ev_epoll1_linux.h

@@ -27,7 +27,6 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
@@ -47,7 +46,7 @@ namespace experimental {
 class Epoll1EventHandle;
 
 // Definition of epoll1 based poller.
-class Epoll1Poller : public PosixEventPoller, public Forkable {
+class Epoll1Poller : public PosixEventPoller {
  public:
   explicit Epoll1Poller(Scheduler* scheduler);
   EventHandle* CreateHandle(int fd, absl::string_view name,
@@ -131,7 +130,7 @@ class Epoll1Poller : public PosixEventPoller, public Forkable {
 
 // Return an instance of a epoll1 based poller tied to the specified event
 // engine.
-Epoll1Poller* MakeEpoll1Poller(Scheduler* scheduler);
+std::shared_ptr<Epoll1Poller> MakeEpoll1Poller(Scheduler* scheduler);
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/event_engine/posix_engine/ev_poll_posix.cc

@@ -19,7 +19,6 @@
 #include <stdint.h>
 
 #include <atomic>
-#include <initializer_list>
 #include <list>
 #include <memory>
 #include <utility>
@@ -74,13 +73,13 @@ using Events = absl::InlinedVector<PollEventHandle*, 5>;
 
 class PollEventHandle : public EventHandle {
  public:
-  PollEventHandle(int fd, PollPoller* poller)
+  PollEventHandle(int fd, std::shared_ptr<PollPoller> poller)
       : fd_(fd),
         pending_actions_(0),
         fork_fd_list_(this),
         poller_handles_list_(this),
-        poller_(poller),
         scheduler_(poller->GetScheduler()),
+        poller_(std::move(poller)),
         is_orphaned_(false),
         is_shutdown_(false),
         closed_(false),
@@ -93,11 +92,10 @@ class PollEventHandle : public EventHandle {
         read_closure_(reinterpret_cast<PosixEngineClosure*>(kClosureNotReady)),
         write_closure_(
             reinterpret_cast<PosixEngineClosure*>(kClosureNotReady)) {
-    poller_->Ref();
     grpc_core::MutexLock lock(&poller_->mu_);
     poller_->PollerHandlesListAddHandle(this);
   }
-  PollPoller* Poller() override { return poller_; }
+  PollPoller* Poller() override { return poller_.get(); }
   bool SetPendingActions(bool pending_read, bool pending_write) {
     pending_actions_ |= pending_read;
     if (pending_write) {
@@ -185,7 +183,6 @@ class PollEventHandle : public EventHandle {
       if (on_done_ != nullptr) {
         scheduler_->Run(on_done_);
       }
-      poller_->Unref();
       delete this;
     }
   }
@@ -211,8 +208,8 @@ class PollEventHandle : public EventHandle {
   int pending_actions_;
   PollPoller::HandlesList fork_fd_list_;
   PollPoller::HandlesList poller_handles_list_;
-  PollPoller* poller_;
   Scheduler* scheduler_;
+  std::shared_ptr<PollPoller> poller_;
   bool is_orphaned_;
   bool is_shutdown_;
   bool closed_;
@@ -344,7 +341,7 @@ EventHandle* PollPoller::CreateHandle(int fd, absl::string_view /*name*/,
   // Avoid unused-parameter warning for debug-only parameter
   (void)track_err;
   GPR_DEBUG_ASSERT(track_err == false);
-  PollEventHandle* handle = new PollEventHandle(fd, this);
+  PollEventHandle* handle = new PollEventHandle(fd, shared_from_this());
   ForkFdListAddHandle(handle);
   // We need to send a kick to the thread executing Work(..) so that it can
   // add this new Fd into the list of Fds to poll.
@@ -829,10 +826,7 @@ Poller::WorkResult PollPoller::Work(
   return was_kicked_ext ? Poller::WorkResult::kKicked : Poller::WorkResult::kOk;
 }
 
-void PollPoller::Shutdown() {
-  ForkPollerListRemovePoller(this);
-  Unref();
-}
+void PollPoller::Shutdown() { ForkPollerListRemovePoller(this); }
 
 void PollPoller::PrepareFork() { Kick(); }
 // TODO(vigneshbabu): implement
@@ -845,10 +839,11 @@ void PollPoller::Close() {
   closed_ = true;
 }
 
-PollPoller* MakePollPoller(Scheduler* scheduler, bool use_phony_poll) {
+std::shared_ptr<PollPoller> MakePollPoller(Scheduler* scheduler,
+                                           bool use_phony_poll) {
   static bool kPollPollerSupported = InitPollPollerPosix();
   if (kPollPollerSupported) {
-    return new PollPoller(scheduler, use_phony_poll);
+    return std::make_shared<PollPoller>(scheduler, use_phony_poll);
   }
   return nullptr;
 }
@@ -886,8 +881,8 @@ void PollPoller::Kick() { grpc_core::Crash("unimplemented"); }
 
 // If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
 // nullptr.
-PollPoller* MakePollPoller(Scheduler* /*scheduler*/,
-                           bool /* use_phony_poll */) {
+std::shared_ptr<PollPoller> MakePollPoller(Scheduler* /*scheduler*/,
+                                           bool /* use_phony_poll */) {
   return nullptr;
 }
 

data/src/core/lib/event_engine/posix_engine/ev_poll_posix.h

@@ -17,7 +17,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <atomic>
 #include <memory>
 #include <string>
 
@@ -27,7 +26,6 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
@@ -39,7 +37,8 @@ namespace experimental {
 class PollEventHandle;
 
 // Definition of poll based poller.
-class PollPoller : public PosixEventPoller, public Forkable {
+class PollPoller : public PosixEventPoller,
+                   public std::enable_shared_from_this<PollPoller> {
  public:
   explicit PollPoller(Scheduler* scheduler);
   PollPoller(Scheduler* scheduler, bool use_phony_poll);
@@ -63,12 +62,6 @@ class PollPoller : public PosixEventPoller, public Forkable {
   void Close();
 
  private:
-  void Ref() { ref_count_.fetch_add(1, std::memory_order_relaxed); }
-  void Unref() {
-    if (ref_count_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
-      delete this;
-    }
-  }
   void KickExternal(bool ext);
   void PollerHandlesListAddHandle(PollEventHandle* handle)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
@@ -84,7 +77,6 @@ class PollPoller : public PosixEventPoller, public Forkable {
   };
   grpc_core::Mutex mu_;
   Scheduler* scheduler_;
-  std::atomic<int> ref_count_{1};
   bool use_phony_poll_;
   bool was_kicked_ ABSL_GUARDED_BY(mu_);
   bool was_kicked_ext_ ABSL_GUARDED_BY(mu_);
@@ -98,7 +90,8 @@ class PollPoller : public PosixEventPoller, public Forkable {
 // It use_phony_poll is true, it implies that the poller is declared
 // non-polling and any attempt to schedule a blocking poll will result in a
 // crash failure.
-PollPoller* MakePollPoller(Scheduler* scheduler, bool use_phony_poll);
+std::shared_ptr<PollPoller> MakePollPoller(Scheduler* scheduler,
+                                           bool use_phony_poll);
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/event_engine/posix_engine/event_poller.h

@@ -24,6 +24,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 
+#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
 
@@ -86,7 +87,8 @@ class EventHandle {
   virtual ~EventHandle() = default;
 };
 
-class PosixEventPoller : public grpc_event_engine::experimental::Poller {
+class PosixEventPoller : public grpc_event_engine::experimental::Poller,
+                         public Forkable {
  public:
   // Return an opaque handle to perform actions on the provided file descriptor.
   virtual EventHandle* CreateHandle(int fd, absl::string_view name,

data/src/core/lib/event_engine/posix_engine/event_poller_posix_default.cc

@@ -14,13 +14,18 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+#include <string>
+
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
 #include "src/core/lib/config/config_vars.h"
+#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/posix_engine/ev_epoll1_linux.h"
 #include "src/core/lib/event_engine/posix_engine/ev_poll_posix.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
+#include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/iomgr/port.h"
 
 namespace grpc_event_engine {
@@ -28,15 +33,25 @@ namespace experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 namespace {
+// TODO(yijiem): this object is thread-unsafe, if we are creating pollers in
+// multiple threads (e.g. multiple event engines) or if we are creating pollers
+// while we are forking then we will run into issues.
+grpc_core::NoDestruct<ObjectGroupForkHandler> g_poller_fork_manager;
+
+class PollerForkCallbackMethods {
+ public:
+  static void Prefork() { g_poller_fork_manager->Prefork(); }
+  static void PostforkParent() { g_poller_fork_manager->PostforkParent(); }
+  static void PostforkChild() { g_poller_fork_manager->PostforkChild(); }
+};
 
 bool PollStrategyMatches(absl::string_view strategy, absl::string_view want) {
   return strategy == "all" || strategy == want;
 }
-
 }  // namespace
 
-PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler) {
-  PosixEventPoller* poller = nullptr;
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* scheduler) {
+  std::shared_ptr<PosixEventPoller> poller;
   auto strings =
       absl::StrSplit(grpc_core::ConfigVars::Get().PollStrategy(), ',');
   for (auto it = strings.begin(); it != strings.end() && poller == nullptr;
@@ -53,12 +68,16 @@ PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler) {
       poller = MakePollPoller(scheduler, /*use_phony_poll=*/true);
     }
   }
+  g_poller_fork_manager->RegisterForkable(
+      poller, PollerForkCallbackMethods::Prefork,
+      PollerForkCallbackMethods::PostforkParent,
+      PollerForkCallbackMethods::PostforkChild);
   return poller;
 }
 
 #else  // GRPC_POSIX_SOCKET_TCP
 
-PosixEventPoller* MakeDefaultPoller(Scheduler* /*scheduler*/) {
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* /*scheduler*/) {
   return nullptr;
 }
 

data/src/core/lib/event_engine/posix_engine/event_poller_posix_default.h

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
 namespace grpc_event_engine {
 namespace experimental {
 
@@ -25,7 +27,7 @@ class Scheduler;
 
 // Return an instance of an event poller which is tied to the specified
 // scheduler.
-PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler);
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* scheduler);
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/event_engine/posix_engine/grpc_polled_fd_posix.h

@@ -17,6 +17,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/port.h"
 
 #if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
@@ -42,7 +47,6 @@
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
-#include "src/core/lib/iomgr/error.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -80,8 +84,9 @@ class GrpcPolledFdPosix : public GrpcPolledFd {
            bytes_available > 0;
   }
 
-  void ShutdownLocked(grpc_error_handle error) override {
+  bool ShutdownLocked(absl::Status error) override {
     handle_->ShutdownHandle(error);
+    return true;
   }
 
   ares_socket_t GetWrappedAresSocketLocked() override { return as_; }
@@ -105,9 +110,12 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
     }
   }
 
-  GrpcPolledFd* NewGrpcPolledFdLocked(ares_socket_t as) override {
+  void Initialize(grpc_core::Mutex*, EventEngine*) override {}
+
+  std::unique_ptr<GrpcPolledFd> NewGrpcPolledFdLocked(
+      ares_socket_t as) override {
     owned_fds_.insert(as);
-    return new GrpcPolledFdPosix(
+    return std::make_unique<GrpcPolledFdPosix>(
         as,
         poller_->CreateHandle(as, "c-ares socket", poller_->CanTrackErrors()));
   }

data/src/core/lib/event_engine/posix_engine/internal_errqueue.cc

@@ -16,8 +16,6 @@
 
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
 
-#include <string>
-
 #include <grpc/support/log.h>
 
 #include "src/core/lib/iomgr/port.h"

data/src/core/lib/event_engine/posix_engine/posix_endpoint.cc

@@ -1246,8 +1246,7 @@ PosixEndpointImpl::PosixEndpointImpl(EventHandle* handle,
   GPR_ASSERT(options.resource_quota != nullptr);
   auto peer_addr_string = sock.PeerAddressString();
   mem_quota_ = options.resource_quota->memory_quota();
-  memory_owner_ = mem_quota_->CreateMemoryOwner(
-      peer_addr_string.ok() ? *peer_addr_string : "");
+  memory_owner_ = mem_quota_->CreateMemoryOwner();
   self_reservation_ = memory_owner_.MakeReservation(sizeof(PosixEndpointImpl));
   auto local_address = sock.LocalAddress();
   if (local_address.ok()) {

data/src/core/lib/event_engine/posix_engine/posix_endpoint.h

@@ -29,7 +29,6 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/hash/hash.h"
-#include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 

data/src/core/lib/event_engine/posix_engine/posix_engine.cc

@@ -27,7 +27,6 @@
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 
@@ -38,6 +37,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix.h"
@@ -49,6 +49,7 @@
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/sync.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -78,6 +79,19 @@ using namespace std::chrono_literals;
 namespace grpc_event_engine {
 namespace experimental {
 
+namespace {
+
+grpc_core::NoDestruct<ObjectGroupForkHandler> g_timer_fork_manager;
+
+class TimerForkCallbackMethods {
+ public:
+  static void Prefork() { g_timer_fork_manager->Prefork(); }
+  static void PostforkParent() { g_timer_fork_manager->PostforkParent(); }
+  static void PostforkChild() { g_timer_fork_manager->PostforkChild(); }
+};
+
+}  // namespace
+
 #ifdef GRPC_POSIX_SOCKET_TCP
 
 void AsyncConnect::Start(EventEngine::Duration timeout) {
@@ -304,8 +318,9 @@ PosixEnginePollerManager::PosixEnginePollerManager(
       executor_(std::move(executor)),
       trigger_shutdown_called_(false) {}
 
-PosixEnginePollerManager::PosixEnginePollerManager(PosixEventPoller* poller)
-    : poller_(poller),
+PosixEnginePollerManager::PosixEnginePollerManager(
+    std::shared_ptr<PosixEventPoller> poller)
+    : poller_(std::move(poller)),
       poller_state_(PollerState::kExternal),
       executor_(nullptr),
       trigger_shutdown_called_(false) {
@@ -344,10 +359,14 @@ PosixEnginePollerManager::~PosixEnginePollerManager() {
   }
 }
 
-PosixEventEngine::PosixEventEngine(PosixEventPoller* poller)
+PosixEventEngine::PosixEventEngine(std::shared_ptr<PosixEventPoller> poller)
     : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
-      executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
-      timer_manager_(executor_) {
+      executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u))),
+      timer_manager_(std::make_shared<TimerManager>(executor_)) {
+  g_timer_fork_manager->RegisterForkable(
+      timer_manager_, TimerForkCallbackMethods::Prefork,
+      TimerForkCallbackMethods::PostforkParent,
+      TimerForkCallbackMethods::PostforkChild);
 #if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   poller_manager_ = std::make_shared<PosixEnginePollerManager>(poller);
 #endif
@@ -355,8 +374,12 @@ PosixEventEngine::PosixEventEngine(PosixEventPoller* poller)
 
 PosixEventEngine::PosixEventEngine()
     : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
-      executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
-      timer_manager_(executor_) {
+      executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u))),
+      timer_manager_(std::make_shared<TimerManager>(executor_)) {
+  g_timer_fork_manager->RegisterForkable(
+      timer_manager_, TimerForkCallbackMethods::Prefork,
+      TimerForkCallbackMethods::PostforkParent,
+      TimerForkCallbackMethods::PostforkChild);
 #if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   poller_manager_ = std::make_shared<PosixEnginePollerManager>(executor_);
   // The threadpool must be instantiated after the poller otherwise, the
@@ -436,7 +459,7 @@ PosixEventEngine::~PosixEventEngine() {
     }
     GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
   }
-  timer_manager_.Shutdown();
+  timer_manager_->Shutdown();
 #if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
   if (poller_manager_ != nullptr) {
     poller_manager_->TriggerShutdown();
@@ -449,7 +472,7 @@ 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]);
-  bool r = timer_manager_.TimerCancel(&cd->timer);
+  bool r = timer_manager_->TimerCancel(&cd->timer);
   known_handles_.erase(handle);
   if (r) delete cd;
   return r;
@@ -479,7 +502,7 @@ EventEngine::TaskHandle PosixEventEngine::RunAfterInternal(
     Run(std::move(cb));
     return TaskHandle::kInvalid;
   }
-  auto when_ts = ToTimestamp(timer_manager_.Now(), when);
+  auto when_ts = ToTimestamp(timer_manager_->Now(), when);
   auto* cd = new ClosureData;
   cd->cb = std::move(cb);
   cd->engine = this;
@@ -490,7 +513,7 @@ EventEngine::TaskHandle PosixEventEngine::RunAfterInternal(
   cd->handle = handle;
   GRPC_EVENT_ENGINE_TRACE("PosixEventEngine:%p scheduling callback:%s", this,
                           HandleToString(handle).c_str());
-  timer_manager_.TimerInit(&cd->timer, when_ts, cd);
+  timer_manager_->TimerInit(&cd->timer, when_ts, cd);
   return handle;
 }
 

data/src/core/lib/event_engine/posix_engine/posix_engine.h

@@ -104,9 +104,10 @@ class PosixEnginePollerManager
  public:
   explicit PosixEnginePollerManager(std::shared_ptr<ThreadPool> executor);
   explicit PosixEnginePollerManager(
-      grpc_event_engine::experimental::PosixEventPoller* poller);
+      std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
+          poller);
   grpc_event_engine::experimental::PosixEventPoller* Poller() {
-    return poller_;
+    return poller_.get();
   }
 
   ThreadPool* Executor() { return executor_.get(); }
@@ -124,7 +125,7 @@ class PosixEnginePollerManager
 
  private:
   enum class PollerState { kExternal, kOk, kShuttingDown };
-  grpc_event_engine::experimental::PosixEventPoller* poller_ = nullptr;
+  std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller> poller_;
   std::atomic<PollerState> poller_state_{PollerState::kOk};
   std::shared_ptr<ThreadPool> executor_;
   bool trigger_shutdown_called_;
@@ -160,11 +161,13 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
   };
 
 #ifdef GRPC_POSIX_SOCKET_TCP
-  // Constructs an EventEngine which does not own the poller. Do not call this
-  // constructor directly. Instead use the MakeTestOnlyPosixEventEngine static
-  // method. Its expected to be used only in tests.
+  // Constructs an EventEngine which has a shared ownership of the poller. Do
+  // not call this constructor directly. Instead use the
+  // MakeTestOnlyPosixEventEngine static method. Its expected to be used only in
+  // tests.
   explicit PosixEventEngine(
-      grpc_event_engine::experimental::PosixEventPoller* poller);
+      std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
+          poller);
   PosixEventEngine();
 #else   // GRPC_POSIX_SOCKET_TCP
   PosixEventEngine();
@@ -210,14 +213,15 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
   bool Cancel(TaskHandle handle) override;
 
 #ifdef GRPC_POSIX_SOCKET_TCP
-  // The posix EventEngine returned by this method would not own the poller
-  // and would not be in-charge of driving the poller by calling its Work(..)
-  // method. Instead its upto the test to drive the poller. The returned posix
-  // EventEngine will also not attempt to shutdown the poller since it does not
-  // own it.
+  // The posix EventEngine returned by this method would have a shared ownership
+  // of the poller and would not be in-charge of driving the poller by calling
+  // its Work(..) method. Instead its upto the test to drive the poller. The
+  // returned posix EventEngine will also not attempt to shutdown the poller
+  // since it does not own it.
   static std::shared_ptr<PosixEventEngine> MakeTestOnlyPosixEventEngine(
-      grpc_event_engine::experimental::PosixEventPoller* test_only_poller) {
-    return std::make_shared<PosixEventEngine>(test_only_poller);
+      std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
+          test_only_poller) {
+    return std::make_shared<PosixEventEngine>(std::move(test_only_poller));
   }
 #endif  // GRPC_POSIX_SOCKET_TCP
 
@@ -255,7 +259,7 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
   TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
   std::atomic<intptr_t> aba_token_{0};
   std::shared_ptr<ThreadPool> executor_;
-  TimerManager timer_manager_;
+  std::shared_ptr<TimerManager> timer_manager_;
 #ifdef GRPC_POSIX_SOCKET_TCP
   std::shared_ptr<PosixEnginePollerManager> poller_manager_;
 #endif  // GRPC_POSIX_SOCKET_TCP

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.cc

@@ -17,13 +17,11 @@
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 
 #include <errno.h>
-#include <inttypes.h>
 #include <limits.h>
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>

data/src/core/lib/event_engine/posix_engine/wakeup_fd_eventfd.cc

@@ -17,7 +17,6 @@
 #include <utility>
 
 #include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 
 #include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
 #include "src/core/lib/iomgr/port.h"

data/src/core/lib/event_engine/posix_engine/wakeup_fd_pipe.cc

@@ -18,7 +18,6 @@
 #include <utility>
 
 #include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 
 #include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
 #include "src/core/lib/iomgr/port.h"

data/src/core/lib/event_engine/shim.cc

@@ -45,7 +45,8 @@ bool UseEventEngineClient() {
 bool UseEventEngineListener() {
 // TODO(hork, eryu): Adjust the ifdefs accordingly when event engines become
 // available for other platforms.
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
+#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM) && \
+    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
   return grpc_core::IsEventEngineListenerEnabled();
 #else
   return false;
@@ -53,7 +54,8 @@ bool UseEventEngineListener() {
 }
 
 bool EventEngineSupportsFd() {
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
+#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM) && \
+    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
   return g_event_engine_supports_fd;
 #else
   return false;

data/src/core/lib/event_engine/slice_buffer.cc

@@ -18,7 +18,6 @@
 
 #include <grpc/event_engine/slice.h>
 #include <grpc/event_engine/slice_buffer.h>
-#include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 
 #include "src/core/lib/slice/slice.h"

data/src/core/lib/event_engine/tcp_socket_utils.cc

@@ -45,7 +45,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <initializer_list>
 #include <utility>
 
 #include "absl/status/status.h"

data/src/core/lib/event_engine/thread_pool/thread_pool_factory.cc

@@ -17,18 +17,32 @@
 
 #include <memory>
 
-#include <grpc/support/cpu.h>
-
+#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h"
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/no_destruct.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-std::shared_ptr<ThreadPool> MakeThreadPool(size_t /* reserve_threads */) {
-  return std::make_shared<WorkStealingThreadPool>(
-      grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u));
+namespace {
+grpc_core::NoDestruct<ObjectGroupForkHandler> g_thread_pool_fork_manager;
+
+class ThreadPoolForkCallbackMethods {
+ public:
+  static void Prefork() { g_thread_pool_fork_manager->Prefork(); }
+  static void PostforkParent() { g_thread_pool_fork_manager->PostforkParent(); }
+  static void PostforkChild() { g_thread_pool_fork_manager->PostforkChild(); }
+};
+}  // namespace
+
+std::shared_ptr<ThreadPool> MakeThreadPool(size_t reserve_threads) {
+  auto thread_pool = std::make_shared<WorkStealingThreadPool>(reserve_threads);
+  g_thread_pool_fork_manager->RegisterForkable(
+      thread_pool, ThreadPoolForkCallbackMethods::Prefork,
+      ThreadPoolForkCallbackMethods::PostforkParent,
+      ThreadPoolForkCallbackMethods::PostforkChild);
+  return thread_pool;
 }
 
 }  // namespace experimental