grpc 1.73.0 → 1.75.0

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

@@ -0,0 +1,124 @@
+// Copyright 2025 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 "src/core/lib/event_engine/posix_engine/file_descriptor_collection.h"
+
+#include "absl/strings/substitute.h"
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/util/crash.h"  // IWYU pragma: keep
+#include "src/core/util/strerror.h"
+
+namespace grpc_event_engine::experimental {
+
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+
+namespace {
+
+bool IsForkEnabled() { return grpc_core::IsEventEngineForkEnabled(); }
+
+}  // namespace
+
+FileDescriptorCollection::FileDescriptorCollection(int generation) noexcept
+    : generation_(generation) {}
+
+FileDescriptorCollection::FileDescriptorCollection(
+    FileDescriptorCollection&& other) noexcept
+    : generation_(other.generation_) {
+  grpc_core::MutexLock lock(&other.mu_);
+  file_descriptors_ = std::move(other.file_descriptors_);
+  other.generation_ = -1;
+  other.file_descriptors_.clear();
+}
+
+FileDescriptorCollection& FileDescriptorCollection::operator=(
+    FileDescriptorCollection&& other) noexcept {
+  generation_ = other.generation_;
+  grpc_core::MutexLock self_lock(&mu_);
+  grpc_core::MutexLock other_lock(&other.mu_);
+  file_descriptors_ = std::move(other.file_descriptors_);
+  other.generation_ = -1;
+  other.file_descriptors_.clear();
+  return *this;
+}
+
+FileDescriptor FileDescriptorCollection::Add(int fd) {
+  if (IsForkEnabled()) {
+    grpc_core::MutexLock lock(&mu_);
+    file_descriptors_.emplace(fd);
+  }
+  return FileDescriptor(fd, generation_);
+}
+
+bool FileDescriptorCollection::Remove(const FileDescriptor& fd) {
+  if (!IsForkEnabled()) {
+    return true;
+  }
+  if (fd.generation() == generation_) {
+    grpc_core::MutexLock lock(&mu_);
+    return file_descriptors_.erase(fd.fd()) == 1;
+  }
+  return false;
+}
+
+absl::flat_hash_set<int>
+FileDescriptorCollection::ClearAndReturnRawDescriptors() {
+  if (!IsForkEnabled()) {
+    return {};
+  }
+  grpc_core::MutexLock lock(&mu_);
+  absl::flat_hash_set<int> file_descriptors = std::move(file_descriptors_);
+  // Should not be necessary, but standard is not clear if move would empty
+  // the collection
+  file_descriptors_.clear();
+  return file_descriptors;
+}
+
+#else  // GRPC_ENABLE_FORK_SUPPORT
+
+FileDescriptorCollection::FileDescriptorCollection(
+    int /* generation */) noexcept {}
+
+FileDescriptorCollection::FileDescriptorCollection(
+    FileDescriptorCollection&& other) noexcept = default;
+
+FileDescriptorCollection& FileDescriptorCollection::operator=(
+    FileDescriptorCollection&& other) noexcept = default;
+
+FileDescriptor FileDescriptorCollection::Add(int fd) {
+  return FileDescriptor(fd, 0);
+}
+
+bool FileDescriptorCollection::Remove(const FileDescriptor& /* fd */) {
+  return true;
+}
+
+absl::flat_hash_set<int>
+FileDescriptorCollection::ClearAndReturnRawDescriptors() {
+  return {};
+}
+
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+std::string PosixError::StrError() const {
+  if (ok()) {
+    return "ok";
+  }
+  if (IsWrongGenerationError()) {
+    return "file descriptor was created pre fork";
+  }
+  int value = *errno_value();
+  return absl::Substitute("$0 ($1)", grpc_core::StrError(value), value);
+}
+
+}  // namespace grpc_event_engine::experimental

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

@@ -0,0 +1,243 @@
+// Copyright 2025 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_POSIX_ENGINE_FILE_DESCRIPTOR_COLLECTION_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_FILE_DESCRIPTOR_COLLECTION_H
+
+#include <optional>
+#include <ostream>
+#include <string>
+#include <utility>
+#include <variant>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "src/core/util/sync.h"
+
+namespace grpc_event_engine::experimental {
+
+class PosixError {
+ public:
+  static constexpr PosixError Ok() { return PosixError(kOk); }
+
+  static constexpr PosixError Error(int errno_value) {
+    CHECK_GT(errno_value, 0);
+    return PosixError(errno_value);
+  }
+
+  static constexpr PosixError WrongGeneration() {
+    return PosixError(kWrongGenerationError);
+  }
+
+  constexpr PosixError() : payload_(kOk) {}
+
+  constexpr bool ok() const { return payload_ == kOk; }
+
+  bool IsPosixError() const { return payload_ > 0; }
+
+  bool IsPosixError(int errno_value) const {
+    return errno_value >= 0 && payload_ == errno_value;
+  }
+
+  bool IsWrongGenerationError() const {
+    return payload_ == kWrongGenerationError;
+  }
+
+  std::optional<int> errno_value() const {
+    if (payload_ > 0) return payload_;
+    return std::nullopt;
+  }
+
+  std::string StrError() const;
+
+ private:
+  static constexpr int kWrongGenerationError = -1;
+  static constexpr int kOk = 0;
+
+  explicit constexpr PosixError(int error) : payload_(error) {}
+
+  int payload_;
+};
+
+template <typename T>
+class PosixErrorOr {
+ public:
+  using Payload = std::variant<T, PosixError>;
+
+  constexpr PosixErrorOr() = default;
+  constexpr PosixErrorOr(const PosixErrorOr& other) = default;
+  constexpr PosixErrorOr(PosixErrorOr&& other) = default;
+  constexpr PosixErrorOr(  // NOLINT(google-explicit-constructor)
+      const PosixError& error)
+      : value_(error) {
+    CHECK(!error.ok());
+  }
+  constexpr PosixErrorOr(T&& value)  // NOLINT(google-explicit-constructor)
+      : value_(std::forward<T>(value)) {}
+  PosixErrorOr& operator=(const PosixErrorOr& other) = default;
+  PosixErrorOr& operator=(PosixErrorOr&& other) = default;
+
+  bool ok() const { return std::holds_alternative<T>(value_); }
+
+  std::optional<int> errno_value() const {
+    if (ok()) {
+      return std::nullopt;
+    }
+    return std::get<PosixError>(value_).errno_value();
+  }
+
+  bool IsPosixError() const {
+    const PosixError* error = std::get_if<PosixError>(&value_);
+    return error != nullptr && error->IsPosixError();
+  }
+
+  bool IsPosixError(int errno_value) const {
+    const PosixError* error = std::get_if<PosixError>(&value_);
+    return error != nullptr && error->IsPosixError(errno_value);
+  }
+
+  bool IsWrongGenerationError() const {
+    const PosixError* error = std::get_if<PosixError>(&value_);
+    return error != nullptr && error->IsWrongGenerationError();
+  }
+
+  T* operator->() { return &std::get<T>(value_); }
+
+  const T* operator->() const { return &std::get<T>(value_); }
+
+  T& operator*() { return std::get<T>(value_); }
+
+  const T& value() const { return std::get<T>(value_); }
+
+  T value_or(T default_value) const {
+    if (ok()) {
+      return value();
+    }
+    return default_value;
+  }
+
+  std::string StrError() const {
+    if (ok()) {
+      return "ok";
+    }
+    return std::get<PosixError>(value_).StrError();
+  }
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, PosixErrorOr<T> error) {
+    if (error.ok()) {
+      sink.Append(absl::StrCat(error.value()));
+    } else {
+      sink.Append(error.StrError());
+    }
+  }
+
+ private:
+  Payload value_;
+};
+
+// Represents a file descriptor, potentially associated with a fork generation.
+// When compiling with fork support (GRPC_ENABLE_FORK_SUPPORT is defined),
+// FileDescriptor includes a generation number to track its validity across
+// forks. Otherwise, it only stores the fd.
+class FileDescriptor {
+ public:
+  constexpr FileDescriptor() noexcept = default;
+#if GRPC_ENABLE_FORK_SUPPORT
+  constexpr FileDescriptor(int fd, int generation) noexcept
+      : fd_(fd), generation_(generation) {};
+#else   // GRPC_ENABLE_FORK_SUPPORT
+  constexpr FileDescriptor(int fd, int /* generation */) noexcept : fd_(fd) {};
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+  bool ready() const { return fd_ >= 0; }
+  int fd() const { return fd_; }
+  constexpr static FileDescriptor Invalid() { return FileDescriptor(-1, 0); }
+
+#if GRPC_ENABLE_FORK_SUPPORT
+  int generation() const { return generation_; }
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, FileDescriptor fd) {
+    sink.Append(
+        absl::StrFormat("fd(%d, generation: %d)", fd.fd_, fd.generation_));
+  }
+
+  bool operator==(const FileDescriptor& other) const {
+    return fd_ == other.fd_ && generation_ == other.generation_;
+  }
+#else  // GRPC_ENABLE_FORK_SUPPORT
+  int generation() const { return 0; }
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, FileDescriptor fd) {
+    sink.Append(absl::StrFormat("fd(%d)", fd.fd_));
+  }
+  bool operator==(const FileDescriptor& other) const {
+    return fd_ == other.fd_;
+  }
+
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+  friend std::ostream& operator<<(std::ostream& os, const FileDescriptor& fd) {
+    os << absl::StrCat(fd);
+    return os;
+  }
+
+ private:
+  int fd_ = -1;
+#if GRPC_ENABLE_FORK_SUPPORT
+  int generation_ = 0;
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+};
+
+// Manages a collection of file descriptors, tracking their validity across
+// forks by associating them with a generation number. This is necessary
+// to ensure FDs created before a fork are not used after the fork.
+class FileDescriptorCollection {
+ public:
+  explicit FileDescriptorCollection(int generation) noexcept;
+  FileDescriptorCollection(FileDescriptorCollection&& other) noexcept;
+  FileDescriptorCollection& operator=(
+      FileDescriptorCollection&& other) noexcept;
+  // Adds a raw file descriptor `fd` to the collection and associates it
+  // with the current generation. Simply constructs a new FileDescriptor
+  // instance without adding to a collection if fork is disabled.
+  FileDescriptor Add(int fd);
+  // Removes a FileDescriptor from the collection.
+  // If fork support is disabled, this always returns true.
+  // If fork support is enabled, fd is only removed if its generation matches
+  // the current collection generation. Returns true if the fd was removed.
+  bool Remove(const FileDescriptor& fd);
+  // Clears the internal collection and returns a set of file descriptors
+  absl::flat_hash_set<int> ClearAndReturnRawDescriptors();
+
+  // Returns the current generation number of the collection.
+#if GRPC_ENABLE_FORK_SUPPORT
+  int generation() const { return generation_; }
+#else   // GRPC_ENABLE_FORK_SUPPORT
+  int generation() const { return 0; }
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+ private:
+#if GRPC_ENABLE_FORK_SUPPORT
+  grpc_core::Mutex mu_;
+  absl::flat_hash_set<int> file_descriptors_ ABSL_GUARDED_BY(mu_);
+  // Never changed outside of ctor, no need to synchronize
+  int generation_;
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_FILE_DESCRIPTOR_COLLECTION_H

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

@@ -20,6 +20,9 @@
 
 #include <memory>
 
+#include "absl/base/thread_annotations.h"
+#include "src/core/lib/event_engine/posix_engine/file_descriptor_collection.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/sync.h"
 
@@ -31,7 +34,6 @@
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
-#include <unistd.h>
 
 #include <string>
 #include <unordered_set>
@@ -43,7 +45,6 @@
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #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"
 
 namespace grpc_event_engine::experimental {
 
@@ -57,7 +58,7 @@ class GrpcPolledFdPosix : public GrpcPolledFd {
   ~GrpcPolledFdPosix() override {
     // c-ares library will close the fd. This fd may be picked up immediately by
     // another thread and should not be closed by the following OrphanHandle.
-    int phony_release_fd;
+    FileDescriptor phony_release_fd;
     handle_->OrphanHandle(/*on_done=*/nullptr, &phony_release_fd,
                           "c-ares query finished");
   }
@@ -76,8 +77,7 @@ class GrpcPolledFdPosix : public GrpcPolledFd {
 
   bool IsFdStillReadableLocked() override {
     size_t bytes_available = 0;
-    return ioctl(handle_->WrappedFd(), FIONREAD, &bytes_available) == 0 &&
-           bytes_available > 0;
+    return ioctl(as_, FIONREAD, &bytes_available) == 0 && bytes_available > 0;
   }
 
   bool ShutdownLocked(absl::Status error) override {
@@ -89,6 +89,11 @@ class GrpcPolledFdPosix : public GrpcPolledFd {
 
   const char* GetName() const override { return name_.c_str(); }
 
+  bool IsCurrent() const override {
+    return handle_->Poller()->posix_interface().generation() ==
+           handle_->WrappedFd().generation();
+  }
+
  private:
   const std::string name_;
   const ares_socket_t as_;
@@ -101,6 +106,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
       : poller_(poller) {}
 
   ~GrpcPolledFdFactoryPosix() override {
+    grpc_core::MutexLock lock(&mu_);
     for (auto& fd : owned_fds_) {
       close(fd);
     }
@@ -110,16 +116,23 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
 
   std::unique_ptr<GrpcPolledFd> NewGrpcPolledFdLocked(
       ares_socket_t as) override {
+    grpc_core::MutexLock lock(&mu_);
     owned_fds_.insert(as);
+    CHECK_NE(poller_, nullptr);
+    FileDescriptor fd(as, poller_->posix_interface().generation());
     return std::make_unique<GrpcPolledFdPosix>(
         as,
-        poller_->CreateHandle(as, "c-ares socket", poller_->CanTrackErrors()));
+        poller_->CreateHandle(fd, "c-ares socket", poller_->CanTrackErrors()));
   }
 
   void ConfigureAresChannelLocked(ares_channel channel) override {
     ares_set_socket_functions(channel, &kSockFuncs, this);
     ares_set_socket_configure_callback(
-        channel, &GrpcPolledFdFactoryPosix::ConfigureSocket, nullptr);
+        channel, &GrpcPolledFdFactoryPosix::ConfigureSocket, this);
+  }
+
+  std::unique_ptr<GrpcPolledFdFactory> NewEmptyInstance() const override {
+    return std::make_unique<GrpcPolledFdFactoryPosix>(poller_);
   }
 
  private:
@@ -152,6 +165,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
   static int Close(ares_socket_t as, void* user_data) {
     GrpcPolledFdFactoryPosix* self =
         static_cast<GrpcPolledFdFactoryPosix*>(user_data);
+    grpc_core::MutexLock lock(&self->mu_);
     if (self->owned_fds_.find(as) == self->owned_fds_.end()) {
       // c-ares owns this fd, grpc has never seen it
       return close(as);
@@ -167,17 +181,13 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
   ///   - non-blocking
   ///   - cloexec flag
   ///   - disable nagle
-  static int ConfigureSocket(ares_socket_t fd, int type, void* /*user_data*/) {
-    // clang-format off
-#define RETURN_IF_ERROR(expr) if (!(expr).ok()) { return -1; }
-    // clang-format on
-    PosixSocketWrapper sock(fd);
-    RETURN_IF_ERROR(sock.SetSocketNonBlocking(1));
-    RETURN_IF_ERROR(sock.SetSocketCloexec(1));
-    if (type == SOCK_STREAM) {
-      RETURN_IF_ERROR(sock.SetSocketLowLatency(1));
-    }
-    return 0;
+  static int ConfigureSocket(ares_socket_t as, int type,
+                             void* polled_fd_factory) {
+    auto& posix_interface =
+        static_cast<GrpcPolledFdFactoryPosix*>(polled_fd_factory)
+            ->poller_->posix_interface();
+    return posix_interface.ConfigureSocket({as, posix_interface.generation()},
+                                           type);
   }
 
   const struct ares_socket_functions kSockFuncs = {
@@ -189,9 +199,10 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
   };
 
   PosixEventPoller* poller_;
+  grpc_core::Mutex mu_;
   // fds that are used/owned by grpc - we (grpc) will close them rather than
   // c-ares
-  std::unordered_set<ares_socket_t> owned_fds_;
+  std::unordered_set<ares_socket_t> owned_fds_ ABSL_GUARDED_BY(mu_);
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -17,6 +17,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/log/log.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -34,10 +35,13 @@
 namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_LINUX_ERRQUEUE
-int GetSocketTcpInfo(struct tcp_info* info, int fd) {
+PosixError GetSocketTcpInfo(tcp_info* info,
+                            EventEnginePosixInterface* posix_interface,
+                            const FileDescriptor& fd) {
   memset(info, 0, sizeof(*info));
   info->length = offsetof(tcp_info, length);
-  return getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &(info->length));
+  return posix_interface->GetSockOpt(fd, IPPROTO_TCP, TCP_INFO, info,
+                                     &(info->length));
 }
 #endif
 

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

@@ -18,6 +18,7 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -92,6 +93,8 @@ enum TCPOptStats {
   TCP_NLA_DSACK_DUPS,             // DSACK blocks received
   TCP_NLA_REORD_SEEN,             // reordering events seen
   TCP_NLA_SRTT,                   // smoothed RTT in usecs
+  TCP_NLA_TIMEOUT_REHASH,         // Timeout-triggered rehash attempts
+  TCP_NLA_BYTES_NOTSENT,          // Bytes in write queue not yet sent
 };
 
 // tcp_info from from linux/tcp.h
@@ -161,7 +164,9 @@ struct tcp_info {
 #define TCP_INFO 11
 #endif
 
-int GetSocketTcpInfo(tcp_info* info, int fd);
+PosixError GetSocketTcpInfo(tcp_info* info,
+                            EventEnginePosixInterface* posix_interface,
+                            const FileDescriptor& fd);
 
 #endif  // GRPC_LINUX_ERRQUEUE
 

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

@@ -117,7 +117,7 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
         if (state_.compare_exchange_strong(curr, kClosureNotReady,
                                            std::memory_order_acq_rel,
                                            std::memory_order_acquire)) {
-          scheduler_->Run(closure);
+          thread_pool_->Run(closure);
           return;  // Successful. Return.
         }
         break;  // retry
@@ -131,7 +131,7 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
           absl::Status shutdown_err =
               grpc_core::internal::StatusGetFromHeapPtr(curr & ~kShutdownBit);
           closure->SetStatus(shutdown_err);
-          scheduler_->Run(closure);
+          thread_pool_->Run(closure);
           return;
         }
 
@@ -187,7 +187,7 @@ bool LockfreeEvent::SetShutdown(absl::Status shutdown_error) {
                                            std::memory_order_acquire)) {
           auto closure = reinterpret_cast<PosixEngineClosure*>(curr);
           closure->SetStatus(shutdown_error);
-          scheduler_->Run(closure);
+          thread_pool_->Run(closure);
           return true;
         }
         // 'curr' was a closure but now changed to a different state. We will
@@ -234,7 +234,7 @@ void LockfreeEvent::SetReady() {
           // notify_on (or set_shutdown)
           auto closure = reinterpret_cast<PosixEngineClosure*>(curr);
           closure->SetStatus(absl::OkStatus());
-          scheduler_->Run(closure);
+          thread_pool_->Run(closure);
           return;
         }
         // else the state changed again (only possible by either a racing

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

@@ -21,14 +21,13 @@
 
 #include "absl/status/status.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 
 namespace grpc_event_engine::experimental {
 
-class Scheduler;
-
 class LockfreeEvent {
  public:
-  explicit LockfreeEvent(Scheduler* scheduler) : scheduler_(scheduler) {}
+  explicit LockfreeEvent(ThreadPool* thread_pool) : thread_pool_(thread_pool) {}
 
   LockfreeEvent(const LockfreeEvent&) = delete;
   LockfreeEvent& operator=(const LockfreeEvent&) = delete;
@@ -62,7 +61,7 @@ class LockfreeEvent {
   enum State { kClosureNotReady = 0, kClosureReady = 2, kShutdownBit = 1 };
 
   std::atomic<intptr_t> state_;
-  Scheduler* scheduler_;
+  ThreadPool* thread_pool_;
 };
 
 }  // namespace grpc_event_engine::experimental