grpc 1.48.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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

@@ -0,0 +1,98 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/event_engine/forkable.h"
+
+#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
+#include <pthread.h>
+
+#include "absl/container/flat_hash_set.h"
+
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+grpc_core::Mutex g_mu;
+bool g_registered{false};
+absl::flat_hash_set<Forkable*> g_forkables;
+}  // namespace
+
+Forkable::Forkable() { ManageForkable(this); }
+
+Forkable::~Forkable() { StopManagingForkable(this); }
+
+void RegisterForkHandlers() {
+  grpc_core::MutexLock lock(&g_mu);
+  GPR_ASSERT(!absl::exchange(g_registered, true));
+  pthread_atfork(PrepareFork, PostforkParent, PostforkChild);
+};
+
+void PrepareFork() {
+  grpc_core::MutexLock lock(&g_mu);
+  for (auto* forkable : g_forkables) {
+    forkable->PrepareFork();
+  }
+}
+void PostforkParent() {
+  grpc_core::MutexLock lock(&g_mu);
+  for (auto* forkable : g_forkables) {
+    forkable->PostforkParent();
+  }
+}
+
+void PostforkChild() {
+  grpc_core::MutexLock lock(&g_mu);
+  for (auto* forkable : g_forkables) {
+    forkable->PostforkChild();
+  }
+}
+
+void ManageForkable(Forkable* forkable) {
+  grpc_core::MutexLock lock(&g_mu);
+  g_forkables.insert(forkable);
+}
+
+void StopManagingForkable(Forkable* forkable) {
+  grpc_core::MutexLock lock(&g_mu);
+  g_forkables.erase(forkable);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#else  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
+namespace grpc_event_engine {
+namespace experimental {
+
+Forkable::Forkable() {}
+Forkable::~Forkable() {}
+
+void RegisterForkHandlers() {}
+void PrepareFork() {}
+void PostforkParent() {}
+void PostforkChild() {}
+
+void ManageForkable(Forkable* /* forkable */) {}
+void StopManagingForkable(Forkable* /* forkable */) {}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK

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

@@ -0,0 +1,61 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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_FORKABLE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
+
+#include <grpc/support/port_platform.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Register fork handlers with the system, enabling fork support.
+//
+// This provides pthread-based support for fork events. Any objects that
+// implement Forkable can register themselves with this system using
+// ManageForkable, and their respective methods will be called upon fork.
+//
+// This should be called once upon grpc_initialization.
+void RegisterForkHandlers();
+
+// Global callback for pthread_atfork's *prepare argument
+void PrepareFork();
+// Global callback for pthread_atfork's *parent argument
+void PostforkParent();
+// Global callback for pthread_atfork's *child argument
+void PostforkChild();
+
+// An interface to be implemented by EventEngines that wish to have managed fork
+// support.
+class Forkable {
+ public:
+  Forkable();
+  virtual ~Forkable();
+  virtual void PrepareFork() = 0;
+  virtual void PostforkParent() = 0;
+  virtual void PostforkChild() = 0;
+};
+
+// Add Forkables from the set of objects that are supported.
+// Upon fork, each forkable will have its respective fork hooks called on
+// the thread that invoked the fork.
+//
+// Relative ordering of fork callback operations is not guaranteed.
+void ManageForkable(Forkable* forkable);
+// Remove a forkable from the managed set.
+void StopManagingForkable(Forkable* forkable);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H

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

@@ -0,0 +1,54 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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_POLLER_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POLLER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/types/variant.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// A generic cross-platform "poller" concept.
+// Concrete implementations will likely manage a set of sockets/file
+// descriptors/etc, allowing threads to drive polling and event processing via
+// Work(...).
+class Poller {
+ public:
+  // This initial vector size may need to be tuned
+  using Events = absl::InlinedVector<EventEngine::Closure*, 5>;
+  struct DeadlineExceeded {};
+  struct Kicked {};
+  using WorkResult = absl::variant<Events, DeadlineExceeded, Kicked>;
+
+  virtual ~Poller() = default;
+  // Poll once for events, returning a collection of Closures to be executed.
+  //
+  // Returns:
+  //  * absl::AbortedError if it was Kicked.
+  //  * absl::DeadlineExceeded if timeout occurred
+  //  * A collection of closures to execute, otherwise
+  virtual WorkResult Work(EventEngine::Duration timeout) = 0;
+  // Trigger the threads executing Work(..) to break out as soon as possible.
+  virtual void Kick() = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POLLER_H

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 */