grpc 1.52.0 → 1.53.0.pre2

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

@@ -93,7 +93,7 @@ Slice Slice::FromRefcountAndBytes(grpc_slice_refcount* r, const uint8_t* begin,
                                   const uint8_t* end) {
   grpc_slice out;
   out.refcount = r;
-  if (r != grpc_slice_refcount::NoopRefcount()) r->Ref();
+  if (r != grpc_slice_refcount::NoopRefcount()) r->Ref({});
   out.data.refcounted.bytes = const_cast<uint8_t*>(begin);
   out.data.refcounted.length = end - begin;
   return Slice(out);

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

@@ -17,6 +17,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 
+#include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
@@ -40,6 +41,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <initializer_list>
 #include <utility>
 
 #include "absl/status/status.h"
@@ -50,6 +52,7 @@
 
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_event_engine {
@@ -187,8 +190,7 @@ bool ResolvedAddressToV4Mapped(
     memcpy(&addr6_out->sin6_addr.s6_addr[12], &addr4->sin_addr, 4);
     addr6_out->sin6_port = addr4->sin_port;
     *resolved_addr6_out = EventEngine::ResolvedAddress(
-        reinterpret_cast<sockaddr*>(addr6_out),
-        static_cast<socklen_t>(sizeof(sockaddr_in6)));
+        reinterpret_cast<sockaddr*>(addr6_out), sizeof(sockaddr_in6));
     return true;
   }
   return false;
@@ -369,5 +371,19 @@ absl::StatusOr<std::string> ResolvedAddressToURI(
   return uri->ToString();
 }
 
+absl::StatusOr<EventEngine::ResolvedAddress> URIToResolvedAddress(
+    std::string address_str) {
+  grpc_resolved_address addr;
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Parse(address_str);
+  if (!uri.ok()) {
+    gpr_log(GPR_ERROR, "Failed to parse URI. Error: %s",
+            uri.status().ToString().c_str());
+  }
+  GRPC_RETURN_IF_ERROR(uri.status());
+  GPR_ASSERT(grpc_parse_uri(*uri, &addr));
+  return EventEngine::ResolvedAddress(
+      reinterpret_cast<const sockaddr*>(addr.addr), addr.len);
+}
+
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -11,8 +11,8 @@
 // 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_TCP_SOCKET_UTILS_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_TCP_SOCKET_UTILS_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_TCP_SOCKET_UTILS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_TCP_SOCKET_UTILS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -79,7 +79,12 @@ absl::StatusOr<std::string> ResolvedAddressToNormalizedString(
 absl::StatusOr<std::string> ResolvedAddressToURI(
     const EventEngine::ResolvedAddress& resolved_address);
 
+// Given a URI string, returns the corresponding resolved address if the URI
+// is valid. Otherwise it returns an appropriate error.
+absl::StatusOr<EventEngine::ResolvedAddress> URIToResolvedAddress(
+    std::string address_str);
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_TCP_SOCKET_UTILS_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_TCP_SOCKET_UTILS_H

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

@@ -0,0 +1,29 @@
+// Copyright 2023 The 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/thread_local.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+thread_local bool g_thread_local{false};
+}  // namespace
+
+void ThreadLocal::SetIsEventEngineThread(bool is) { g_thread_local = is; }
+bool ThreadLocal::IsEventEngineThread() { return g_thread_local; }
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,32 @@
+// Copyright 2023 The 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_SRC_CORE_LIB_EVENT_ENGINE_THREAD_LOCAL_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_LOCAL_H
+#include <grpc/support/port_platform.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// A lightweight facility to allow gpr's fork handlers and
+/// EventEngine::Forkables to coordinate.
+class ThreadLocal {
+ public:
+  static void SetIsEventEngineThread(bool is_local);
+  static bool IsEventEngineThread();
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_LOCAL_H

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

@@ -30,18 +30,13 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/event_engine/thread_local.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/gprpp/time.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-namespace {
-// TODO(drfloob): Remove this, and replace it with the WorkQueue* for the
-// current thread (with nullptr indicating not a threadpool thread).
-thread_local bool g_threadpool_thread;
-}  // namespace
-
 void ThreadPool::StartThread(StatePtr state, StartThreadReason reason) {
   state->thread_count.Add();
   const auto now = grpc_core::Timestamp::Now();
@@ -76,7 +71,7 @@ void ThreadPool::StartThread(StatePtr state, StartThreadReason reason) {
       "event_engine",
       [](void* arg) {
         std::unique_ptr<ThreadArg> a(static_cast<ThreadArg*>(arg));
-        g_threadpool_thread = true;
+        ThreadLocal::SetIsEventEngineThread(true);
         switch (a->reason) {
           case StartThreadReason::kInitialPool:
             break;
@@ -107,33 +102,26 @@ void ThreadPool::ThreadFunc(StatePtr state) {
 }
 
 bool ThreadPool::Queue::Step() {
-  grpc_core::ReleasableMutexLock lock(&mu_);
+  grpc_core::ReleasableMutexLock lock(&queue_mu_);
   // Wait until work is available or we are shutting down.
-  while (state_ == State::kRunning && callbacks_.empty()) {
+  while (!shutdown_ && !forking_ && callbacks_.empty()) {
     // If there are too many threads waiting, then quit this thread.
     // TODO(ctiller): wait some time in this case to be sure.
     if (threads_waiting_ >= reserve_threads_) {
       threads_waiting_++;
-      bool timeout = cv_.WaitWithTimeout(&mu_, absl::Seconds(30));
+      bool timeout = cv_.WaitWithTimeout(&queue_mu_, absl::Seconds(30));
       threads_waiting_--;
       if (timeout && threads_waiting_ >= reserve_threads_) {
         return false;
       }
     } else {
       threads_waiting_++;
-      cv_.Wait(&mu_);
+      cv_.Wait(&queue_mu_);
       threads_waiting_--;
     }
   }
-  switch (state_) {
-    case State::kRunning:
-      break;
-    case State::kForking:
-      return false;
-    case State::kShutdown:
-      if (!callbacks_.empty()) break;
-      return false;
-  }
+  if (forking_) return false;
+  if (shutdown_ && callbacks_.empty()) return false;
   GPR_ASSERT(!callbacks_.empty());
   auto callback = std::move(callbacks_.front());
   callbacks_.pop();
@@ -148,14 +136,18 @@ ThreadPool::ThreadPool() {
   }
 }
 
+bool ThreadPool::IsThreadPoolThread() {
+  return ThreadLocal::IsEventEngineThread();
+}
+
 void ThreadPool::Quiesce() {
-  state_->queue.SetShutdown();
+  state_->queue.SetShutdown(true);
   // Wait until all threads are exited.
   // Note that if this is a threadpool thread then we won't exit this thread
   // until the callstack unwinds a little, so we need to wait for just one
   // thread running instead of zero.
-  state_->thread_count.BlockUntilThreadCount(g_threadpool_thread ? 1 : 0,
-                                             "shutting down");
+  state_->thread_count.BlockUntilThreadCount(
+      ThreadLocal::IsEventEngineThread() ? 1 : 0, "shutting down");
   quiesced_.store(true, std::memory_order_relaxed);
 }
 
@@ -175,81 +167,65 @@ void ThreadPool::Run(EventEngine::Closure* closure) {
 }
 
 bool ThreadPool::Queue::Add(absl::AnyInvocable<void()> callback) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(&queue_mu_);
   // Add works to the callbacks list
   callbacks_.push(std::move(callback));
   cv_.Signal();
-  switch (state_) {
-    case State::kRunning:
-    case State::kShutdown:
-      return callbacks_.size() > threads_waiting_;
-    case State::kForking:
-      return false;
-  }
-  GPR_UNREACHABLE_CODE(return false);
+  if (forking_) return false;
+  return callbacks_.size() > threads_waiting_;
 }
 
 bool ThreadPool::Queue::IsBacklogged() {
-  grpc_core::MutexLock lock(&mu_);
-  switch (state_) {
-    case State::kRunning:
-    case State::kShutdown:
-      return callbacks_.size() > 1;
-    case State::kForking:
-      return false;
-  }
-  GPR_UNREACHABLE_CODE(return false);
+  grpc_core::MutexLock lock(&queue_mu_);
+  if (forking_) return false;
+  return callbacks_.size() > 1;
 }
 
 void ThreadPool::Queue::SleepIfRunning() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(&queue_mu_);
   auto end = grpc_core::Duration::Seconds(1) + grpc_core::Timestamp::Now();
   while (true) {
     grpc_core::Timestamp now = grpc_core::Timestamp::Now();
-    if (now >= end) return;
-    switch (state_) {
-      case State::kRunning:
-      case State::kShutdown:
-        cv_.WaitWithTimeout(&mu_, absl::Milliseconds((end - now).millis()));
-        break;
-      case State::kForking:
-        return;
-    }
+    if (now >= end || forking_) return;
+    cv_.WaitWithTimeout(&queue_mu_, absl::Milliseconds((end - now).millis()));
   }
 }
 
-void ThreadPool::Queue::SetState(State state) {
-  grpc_core::MutexLock lock(&mu_);
-  if (state == State::kRunning) {
-    GPR_ASSERT(state_ != State::kRunning);
-  } else {
-    GPR_ASSERT(state_ == State::kRunning);
-  }
-  state_ = state;
+void ThreadPool::Queue::SetShutdown(bool is_shutdown) {
+  grpc_core::MutexLock lock(&queue_mu_);
+  auto was_shutdown = std::exchange(shutdown_, is_shutdown);
+  GPR_ASSERT(is_shutdown != was_shutdown);
+  cv_.SignalAll();
+}
+
+void ThreadPool::Queue::SetForking(bool is_forking) {
+  grpc_core::MutexLock lock(&queue_mu_);
+  auto was_forking = std::exchange(forking_, is_forking);
+  GPR_ASSERT(is_forking != was_forking);
   cv_.SignalAll();
 }
 
 void ThreadPool::ThreadCount::Add() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(&thread_count_mu_);
   ++threads_;
 }
 
 void ThreadPool::ThreadCount::Remove() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(&thread_count_mu_);
   --threads_;
   cv_.Signal();
 }
 
 void ThreadPool::ThreadCount::BlockUntilThreadCount(int threads,
                                                     const char* why) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(&thread_count_mu_);
   auto last_log = absl::Now();
   while (threads_ > threads) {
     // Wait for all threads to exit.
     // At least once every three seconds (but no faster than once per second in
     // the event of spurious wakeups) log a message indicating we're waiting to
     // fork.
-    cv_.WaitWithTimeout(&mu_, absl::Seconds(3));
+    cv_.WaitWithTimeout(&thread_count_mu_, absl::Seconds(3));
     if (threads_ > threads && absl::Now() - last_log > absl::Seconds(1)) {
       gpr_log(GPR_ERROR, "Waiting for thread pool to idle before %s", why);
       last_log = absl::Now();
@@ -258,7 +234,7 @@ void ThreadPool::ThreadCount::BlockUntilThreadCount(int threads,
 }
 
 void ThreadPool::PrepareFork() {
-  state_->queue.SetForking();
+  state_->queue.SetForking(true);
   state_->thread_count.BlockUntilThreadCount(0, "forking");
 }
 
@@ -267,7 +243,7 @@ void ThreadPool::PostforkParent() { Postfork(); }
 void ThreadPool::PostforkChild() { Postfork(); }
 
 void ThreadPool::Postfork() {
-  state_->queue.Reset();
+  state_->queue.SetForking(false);
   for (unsigned i = 0; i < reserve_threads_; i++) {
     StartThread(state_, StartThreadReason::kInitialPool);
   }

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

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
 
 #include <grpc/support/port_platform.h>
 
@@ -59,32 +59,36 @@ class ThreadPool final : public Forkable, public Executor {
   void PostforkParent() override;
   void PostforkChild() override;
 
+  // Returns true if the current thread is a thread pool thread.
+  static bool IsThreadPoolThread();
+
  private:
   class Queue {
    public:
     explicit Queue(unsigned reserve_threads)
         : reserve_threads_(reserve_threads) {}
     bool Step();
-    void SetShutdown() { SetState(State::kShutdown); }
-    void SetForking() { SetState(State::kForking); }
     // Add a callback to the queue.
     // Return true if we should also spin up a new thread.
     bool Add(absl::AnyInvocable<void()> callback);
-    void Reset() { SetState(State::kRunning); }
+    void SetShutdown(bool is_shutdown);
+    void SetForking(bool is_forking);
     bool IsBacklogged();
     void SleepIfRunning();
 
    private:
-    enum class State { kRunning, kShutdown, kForking };
-
-    void SetState(State state);
-
-    grpc_core::Mutex mu_;
-    grpc_core::CondVar cv_;
-    std::queue<absl::AnyInvocable<void()>> callbacks_ ABSL_GUARDED_BY(mu_);
-    unsigned threads_waiting_ ABSL_GUARDED_BY(mu_) = 0;
     const unsigned reserve_threads_;
-    State state_ ABSL_GUARDED_BY(mu_) = State::kRunning;
+    grpc_core::Mutex queue_mu_;
+    grpc_core::CondVar cv_;
+    std::queue<absl::AnyInvocable<void()>> callbacks_
+        ABSL_GUARDED_BY(queue_mu_);
+    unsigned threads_waiting_ ABSL_GUARDED_BY(queue_mu_) = 0;
+    // Track shutdown and fork bits separately.
+    // It's possible for a ThreadPool to initiate shut down while fork handlers
+    // are running, and similarly possible for a fork event to occur during
+    // shutdown.
+    bool shutdown_ ABSL_GUARDED_BY(queue_mu_) = false;
+    bool forking_ ABSL_GUARDED_BY(queue_mu_) = false;
   };
 
   class ThreadCount {
@@ -94,9 +98,9 @@ class ThreadPool final : public Forkable, public Executor {
     void BlockUntilThreadCount(int threads, const char* why);
 
    private:
-    grpc_core::Mutex mu_;
+    grpc_core::Mutex thread_count_mu_;
     grpc_core::CondVar cv_;
-    int threads_ ABSL_GUARDED_BY(mu_) = 0;
+    int threads_ ABSL_GUARDED_BY(thread_count_mu_) = 0;
   };
 
   struct State {
@@ -134,4 +138,4 @@ class ThreadPool final : public Forkable, public Executor {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H

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

@@ -11,8 +11,8 @@
 // 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_TIME_UTIL_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
 
 #include <grpc/support/port_platform.h>
 
@@ -29,4 +29,4 @@ size_t Milliseconds(EventEngine::Duration d);
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H

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

@@ -16,3 +16,9 @@
 #include "src/core/lib/debug/trace.h"
 
 grpc_core::TraceFlag grpc_event_engine_trace(false, "event_engine");
+grpc_core::TraceFlag grpc_event_engine_endpoint_trace(false,
+                                                      "event_engine_endpoint");
+grpc_core::TraceFlag grpc_event_engine_endpoint_data_trace(
+    false, "event_engine_endpoint_data");
+grpc_core::TraceFlag grpc_event_engine_poller_trace(false,
+                                                    "event_engine_poller");

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

@@ -11,8 +11,8 @@
 // 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_TRACE_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_TRACE_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_TRACE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_TRACE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -21,10 +21,23 @@
 #include "src/core/lib/debug/trace.h"
 
 extern grpc_core::TraceFlag grpc_event_engine_trace;
+extern grpc_core::TraceFlag grpc_event_engine_endpoint_data_trace;
+extern grpc_core::TraceFlag grpc_event_engine_poller_trace;
+extern grpc_core::TraceFlag grpc_event_engine_endpoint_trace;
 
 #define GRPC_EVENT_ENGINE_TRACE(format, ...)                   \
   if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {      \
     gpr_log(GPR_DEBUG, "(event_engine) " format, __VA_ARGS__); \
   }
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_TRACE_H
+#define GRPC_EVENT_ENGINE_ENDPOINT_TRACE(format, ...)                   \
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_endpoint_trace)) {      \
+    gpr_log(GPR_DEBUG, "(event_engine endpoint) " format, __VA_ARGS__); \
+  }
+
+#define GRPC_EVENT_ENGINE_POLLER_TRACE(format, ...)                   \
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_poller_trace)) {      \
+    gpr_log(GPR_DEBUG, "(event_engine poller) " format, __VA_ARGS__); \
+  }
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_TRACE_H

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

@@ -28,8 +28,8 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-std::string HandleToString(EventEngine::TaskHandle handle) {
-  return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
+std::string HandleToStringInternal(uintptr_t a, uintptr_t b) {
+  return absl::StrCat("{", a, ",", b, "}");
 }
 
 grpc_core::Timestamp ToTimestamp(grpc_core::Timestamp now,

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

@@ -11,11 +11,13 @@
 // 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_UTILS_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_UTILS_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_UTILS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_UTILS_H
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <string>
 
 #include <grpc/event_engine/event_engine.h>
@@ -25,7 +27,13 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-std::string HandleToString(EventEngine::TaskHandle handle);
+std::string HandleToStringInternal(uintptr_t a, uintptr_t b);
+
+// Returns a string representation of the EventEngine::*Handle types
+template <typename Handle>
+std::string HandleToString(const Handle& handle) {
+  return HandleToStringInternal(handle.keys[0], handle.keys[1]);
+}
 
 grpc_core::Timestamp ToTimestamp(grpc_core::Timestamp now,
                                  EventEngine::Duration delta);
@@ -33,4 +41,4 @@ grpc_core::Timestamp ToTimestamp(grpc_core::Timestamp now,
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_UTILS_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_UTILS_H