grpc 1.52.0 → 1.53.0

data/src/core/lib/event_engine/windows/windows_engine.cc

@@ -26,34 +26,68 @@
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
 
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+#include "src/core/lib/event_engine/common_closures.h"
+#include "src/core/lib/event_engine/executor/executor.h"
 #include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
+#include "src/core/lib/event_engine/windows/windows_endpoint.h"
 #include "src/core/lib/event_engine/windows/windows_engine.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/error.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
+// ---- IOCPWorkClosure ----
+
+WindowsEventEngine::IOCPWorkClosure::IOCPWorkClosure(Executor* executor,
+                                                     IOCP* iocp)
+    : executor_(executor), iocp_(iocp) {
+  executor_->Run(this);
+}
+
+void WindowsEventEngine::IOCPWorkClosure::Run() {
+  auto result = iocp_->Work(std::chrono::seconds(60), [this] {
+    workers_.fetch_add(1);
+    executor_->Run(this);
+  });
+  if (result == Poller::WorkResult::kDeadlineExceeded) {
+    // iocp received no messages. restart the worker
+    workers_.fetch_add(1);
+    executor_->Run(this);
+  }
+  if (workers_.fetch_sub(1) == 1) done_signal_.Notify();
+}
+
+void WindowsEventEngine::IOCPWorkClosure::WaitForShutdown() {
+  done_signal_.WaitForNotification();
+}
+
+// ---- WindowsEventEngine ----
+
 // TODO(hork): The iomgr timer and execution engine can be reused. It should
 // be separated out from the posix_engine and instantiated as components. It is
 // effectively copied below.
 
-struct WindowsEventEngine::Closure final : public EventEngine::Closure {
+struct WindowsEventEngine::TimerClosure final : public EventEngine::Closure {
   absl::AnyInvocable<void()> cb;
   Timer timer;
   WindowsEventEngine* engine;
   EventEngine::TaskHandle handle;
 
   void Run() override {
-    GRPC_EVENT_ENGINE_TRACE("WindowsEventEngine:%p executing callback:%s",
-                            engine, HandleToString(handle).c_str());
+    GRPC_EVENT_ENGINE_TRACE(
+        "WindowsEventEngine:%p executing callback:%s", engine,
+        HandleToString<EventEngine::TaskHandle>(handle).c_str());
     {
-      grpc_core::MutexLock lock(&engine->mu_);
+      grpc_core::MutexLock lock(&engine->task_mu_);
       engine->known_handles_.erase(handle);
     }
     cb();
@@ -64,7 +98,8 @@ struct WindowsEventEngine::Closure final : public EventEngine::Closure {
 WindowsEventEngine::WindowsEventEngine()
     : executor_(std::make_shared<ThreadPool>()),
       iocp_(executor_.get()),
-      timer_manager_(executor_) {
+      timer_manager_(executor_),
+      iocp_worker_(executor_.get(), &iocp_) {
   WSADATA wsaData;
   int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
   GPR_ASSERT(status == 0);
@@ -72,25 +107,31 @@ WindowsEventEngine::WindowsEventEngine()
 
 WindowsEventEngine::~WindowsEventEngine() {
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(&task_mu_);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
       for (auto handle : known_handles_) {
         gpr_log(GPR_ERROR,
                 "WindowsEventEngine:%p uncleared TaskHandle at shutdown:%s",
-                this, HandleToString(handle).c_str());
+                this, HandleToString<EventEngine::TaskHandle>(handle).c_str());
       }
     }
     GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
-    GPR_ASSERT(WSACleanup() == 0);
-    timer_manager_.Shutdown();
   }
+  iocp_.Kick();
+  iocp_worker_.WaitForShutdown();
+  iocp_.Shutdown();
+  GPR_ASSERT(WSACleanup() == 0);
+  timer_manager_.Shutdown();
   executor_->Quiesce();
 }
 
 bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(&task_mu_);
   if (!known_handles_.contains(handle)) return false;
-  auto* cd = reinterpret_cast<Closure*>(handle.keys[0]);
+  GRPC_EVENT_ENGINE_TRACE(
+      "WindowsEventEngine::%p cancelling %s", this,
+      HandleToString<EventEngine::TaskHandle>(handle).c_str());
+  auto* cd = reinterpret_cast<TimerClosure*>(handle.keys[0]);
   bool r = timer_manager_.TimerCancel(&cd->timer);
   known_handles_.erase(handle);
   if (r) delete cd;
@@ -118,16 +159,17 @@ void WindowsEventEngine::Run(EventEngine::Closure* closure) {
 EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
     Duration when, absl::AnyInvocable<void()> cb) {
   auto when_ts = ToTimestamp(timer_manager_.Now(), when);
-  auto* cd = new Closure;
+  auto* cd = new TimerClosure;
   cd->cb = std::move(cb);
   cd->engine = this;
   EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
                                  aba_token_.fetch_add(1)};
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(&task_mu_);
   known_handles_.insert(handle);
   cd->handle = handle;
-  GRPC_EVENT_ENGINE_TRACE("WindowsEventEngine:%p scheduling callback:%s", this,
-                          HandleToString(handle).c_str());
+  GRPC_EVENT_ENGINE_TRACE(
+      "WindowsEventEngine:%p scheduling callback:%s", this,
+      HandleToString<EventEngine::TaskHandle>(handle).c_str());
   timer_manager_.TimerInit(&cd->timer, when_ts, cd);
   return handle;
 }
@@ -139,15 +181,196 @@ std::unique_ptr<EventEngine::DNSResolver> WindowsEventEngine::GetDNSResolver(
 
 bool WindowsEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
 
-bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
-  grpc_core::Crash("unimplemented");
+void WindowsEventEngine::OnConnectCompleted(
+    std::shared_ptr<ConnectionState> state) {
+  absl::StatusOr<std::unique_ptr<WindowsEndpoint>> endpoint;
+  {
+    // Connection attempt complete!
+    grpc_core::MutexLock lock(&state->mu);
+    state->on_connected = nullptr;
+    {
+      grpc_core::MutexLock handle_lock(&connection_mu_);
+      known_connection_handles_.erase(state->connection_handle);
+    }
+    const auto& overlapped_result = state->socket->write_info()->result();
+    // return early if we cannot cancel the connection timeout timer.
+    if (!Cancel(state->timer_handle)) return;
+    if (overlapped_result.wsa_error != 0) {
+      state->socket->Shutdown(DEBUG_LOCATION, "ConnectEx failure");
+      endpoint = GRPC_WSA_ERROR(overlapped_result.wsa_error, "ConnectEx");
+    } else {
+      // This code should be running in an executor thread already, so the
+      // callback can be run directly.
+      ChannelArgsEndpointConfig cfg;
+      endpoint = std::make_unique<WindowsEndpoint>(
+          state->address, std::move(state->socket), std::move(state->allocator),
+          cfg, executor_.get());
+    }
+  }
+  state->on_connected_user_callback(std::move(endpoint));
 }
 
 EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     OnConnectCallback on_connect, const ResolvedAddress& addr,
-    const EndpointConfig& args, MemoryAllocator memory_allocator,
-    Duration deadline) {
-  grpc_core::Crash("unimplemented");
+    const EndpointConfig& /* args */, MemoryAllocator memory_allocator,
+    Duration timeout) {
+  // TODO(hork): utilize the endpoint config
+  absl::Status status;
+  int istatus;
+  auto uri = ResolvedAddressToURI(addr);
+  if (!uri.ok()) {
+    Run([on_connect = std::move(on_connect), status = uri.status()]() mutable {
+      on_connect(status);
+    });
+    return EventEngine::kInvalidConnectionHandle;
+  }
+  GRPC_EVENT_ENGINE_TRACE("EventEngine::%p connecting to %s", this,
+                          uri->c_str());
+  // Use dualstack sockets where available.
+  ResolvedAddress address = addr;
+  ResolvedAddress addr6_v4mapped;
+  if (ResolvedAddressToV4Mapped(addr, &addr6_v4mapped)) {
+    address = addr6_v4mapped;
+  }
+  SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, nullptr, 0,
+                          IOCP::GetDefaultSocketFlags());
+  if (sock == INVALID_SOCKET) {
+    Run([on_connect = std::move(on_connect),
+         status = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket")]() mutable {
+      on_connect(status);
+    });
+    return EventEngine::kInvalidConnectionHandle;
+  }
+  status = PrepareSocket(sock);
+  if (!status.ok()) {
+    Run([on_connect = std::move(on_connect), status]() mutable {
+      on_connect(status);
+    });
+    return EventEngine::kInvalidConnectionHandle;
+  }
+  // Grab the function pointer for ConnectEx for that specific socket It may
+  // change depending on the interface.
+  LPFN_CONNECTEX ConnectEx;
+  GUID guid = WSAID_CONNECTEX;
+  DWORD ioctl_num_bytes;
+  istatus = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid,
+                     sizeof(guid), &ConnectEx, sizeof(ConnectEx),
+                     &ioctl_num_bytes, nullptr, nullptr);
+  if (istatus != 0) {
+    Run([on_connect = std::move(on_connect),
+         status = GRPC_WSA_ERROR(
+             WSAGetLastError(),
+             "WSAIoctl(SIO_GET_EXTENSION_FUNCTION_POINTER)")]() mutable {
+      on_connect(status);
+    });
+    return EventEngine::kInvalidConnectionHandle;
+  }
+  // bind the local address
+  auto local_address = ResolvedAddressMakeWild6(0);
+  istatus = bind(sock, local_address.address(), local_address.size());
+  if (istatus != 0) {
+    Run([on_connect = std::move(on_connect),
+         status = GRPC_WSA_ERROR(WSAGetLastError(), "bind")]() mutable {
+      on_connect(status);
+    });
+    return EventEngine::kInvalidConnectionHandle;
+  }
+  // Connect
+  auto watched_socket = iocp_.Watch(sock);
+  auto* info = watched_socket->write_info();
+  bool success =
+      ConnectEx(watched_socket->raw_socket(), address.address(), address.size(),
+                nullptr, 0, nullptr, info->overlapped());
+  // It wouldn't be unusual to get a success immediately. But we'll still get an
+  // IOCP notification, so let's ignore it.
+  if (!success) {
+    int last_error = WSAGetLastError();
+    if (last_error != ERROR_IO_PENDING) {
+      Run([on_connect = std::move(on_connect),
+           status = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx")]() mutable {
+        on_connect(status);
+      });
+      watched_socket->Shutdown(DEBUG_LOCATION, "ConnectEx");
+      return EventEngine::kInvalidConnectionHandle;
+    }
+  }
+  GPR_ASSERT(watched_socket != nullptr);
+  auto connection_state = std::make_shared<ConnectionState>();
+  grpc_core::MutexLock lock(&connection_state->mu);
+  connection_state->address = address;
+  connection_state->socket = std::move(watched_socket);
+  connection_state->on_connected_user_callback = std::move(on_connect);
+  connection_state->allocator = std::move(memory_allocator);
+  connection_state->on_connected =
+      SelfDeletingClosure::Create([this, connection_state]() mutable {
+        OnConnectCompleted(std::move(connection_state));
+      });
+  {
+    grpc_core::MutexLock conn_lock(&connection_mu_);
+    connection_state->connection_handle =
+        ConnectionHandle{reinterpret_cast<intptr_t>(connection_state.get()),
+                         aba_token_.fetch_add(1)};
+    known_connection_handles_.insert(connection_state->connection_handle);
+  }
+  connection_state->timer_handle =
+      RunAfter(timeout, [this, connection_state]() {
+        grpc_core::MutexLock lock(&connection_state->mu);
+        if (CancelConnectFromDeadlineTimer(connection_state.get())) {
+          connection_state->on_connected_user_callback(
+              absl::DeadlineExceededError("Connection timed out"));
+        }
+        // else: The connection attempt could not be canceled. We can assume the
+        // connection callback will be called.
+      });
+  connection_state->socket->NotifyOnWrite(connection_state->on_connected);
+  return connection_state->connection_handle;
+}
+
+bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
+  if (TaskHandleComparator<ConnectionHandle>::Eq()(
+          handle, EventEngine::kInvalidConnectionHandle)) {
+    GRPC_EVENT_ENGINE_TRACE("%s",
+                            "Attempted to cancel an invalid connection handle");
+    return false;
+  }
+  // Erase the connection handle, which may be unknown
+  {
+    grpc_core::MutexLock lock(&connection_mu_);
+    if (!known_connection_handles_.contains(handle)) {
+      GRPC_EVENT_ENGINE_TRACE(
+          "Unknown connection handle: %s",
+          HandleToString<EventEngine::ConnectionHandle>(handle).c_str());
+      return false;
+    }
+    known_connection_handles_.erase(handle);
+  }
+  auto* connection_state = reinterpret_cast<ConnectionState*>(handle.keys[0]);
+  grpc_core::MutexLock state_lock(&connection_state->mu);
+  if (!Cancel(connection_state->timer_handle)) return false;
+  return CancelConnectInternalStateLocked(connection_state);
+}
+
+bool WindowsEventEngine::CancelConnectFromDeadlineTimer(
+    ConnectionState* connection_state) {
+  // Erase the connection handle, which is guaranteed to exist.
+  {
+    grpc_core::MutexLock lock(&connection_mu_);
+    GPR_ASSERT(known_connection_handles_.erase(
+                   connection_state->connection_handle) == 1);
+  }
+  return CancelConnectInternalStateLocked(connection_state);
+}
+
+bool WindowsEventEngine::CancelConnectInternalStateLocked(
+    ConnectionState* connection_state) {
+  connection_state->socket->Shutdown(DEBUG_LOCATION, "CancelConnect");
+  // Release the connection_state shared_ptr. connection_state is now invalid.
+  delete connection_state->on_connected;
+  GRPC_EVENT_ENGINE_TRACE("Successfully cancelled connection %s",
+                          HandleToString<EventEngine::ConnectionHandle>(
+                              connection_state->connection_handle)
+                              .c_str());
+  return true;
 }
 
 absl::StatusOr<std::unique_ptr<EventEngine::Listener>>

data/src/core/lib/event_engine/windows/windows_engine.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_WINDOWS_WINDOWS_ENGINE_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
 #include <grpc/support/port_platform.h>
 
 #ifdef GPR_WINDOWS
@@ -32,6 +32,7 @@
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/event_engine/thread_pool.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
+#include "src/core/lib/event_engine/windows/windows_endpoint.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/surface/init_internally.h"
@@ -40,26 +41,10 @@ namespace grpc_event_engine {
 namespace experimental {
 
 // TODO(ctiller): KeepsGrpcInitialized is an interim measure to ensure that
-// event engine is shut down before we shut down iomgr.
+// EventEngine is shut down before we shut down iomgr.
 class WindowsEventEngine : public EventEngine,
                            public grpc_core::KeepsGrpcInitialized {
  public:
-  class WindowsEndpoint : public EventEngine::Endpoint {
-   public:
-    ~WindowsEndpoint() 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 WindowsListener : public EventEngine::Listener {
-   public:
-    ~WindowsListener() override;
-    absl::StatusOr<int> Bind(const ResolvedAddress& addr) override;
-    absl::Status Start() override;
-  };
   class WindowsDNSResolver : public EventEngine::DNSResolver {
    public:
     ~WindowsDNSResolver() override;
@@ -103,17 +88,71 @@ class WindowsEventEngine : public EventEngine,
                       absl::AnyInvocable<void()> closure) override;
   bool Cancel(TaskHandle handle) override;
 
+  // Retrieve the base executor.
+  // This is public because most classes that know the concrete
+  // WindowsEventEngine type are effectively friends.
+  // Not intended for external use.
+  Executor* executor() { return executor_.get(); }
+
  private:
-  struct Closure;
+  // State of an active connection.
+  // Managed by a shared_ptr, owned exclusively by the timeout callback and the
+  // OnConnectCompleted callback herein.
+  struct ConnectionState {
+    // everything is guarded by mu;
+    grpc_core::Mutex mu
+        ABSL_ACQUIRED_BEFORE(WindowsEventEngine::connection_mu_);
+    EventEngine::ConnectionHandle connection_handle ABSL_GUARDED_BY(mu);
+    EventEngine::TaskHandle timer_handle ABSL_GUARDED_BY(mu);
+    EventEngine::OnConnectCallback on_connected_user_callback
+        ABSL_GUARDED_BY(mu);
+    EventEngine::Closure* on_connected ABSL_GUARDED_BY(mu);
+    std::unique_ptr<WinSocket> socket ABSL_GUARDED_BY(mu);
+    EventEngine::ResolvedAddress address ABSL_GUARDED_BY(mu);
+    MemoryAllocator allocator ABSL_GUARDED_BY(mu);
+  };
+
+  // A poll worker which schedules itself unless kicked
+  class IOCPWorkClosure : public EventEngine::Closure {
+   public:
+    explicit IOCPWorkClosure(Executor* executor, IOCP* iocp);
+    void Run() override;
+    void WaitForShutdown();
+
+   private:
+    std::atomic<int> workers_{1};
+    grpc_core::Notification done_signal_;
+    Executor* executor_;
+    IOCP* iocp_;
+  };
+
+  void OnConnectCompleted(std::shared_ptr<ConnectionState> state);
+
+  // CancelConnect called from within the deadline timer.
+  // In this case, the connection_state->mu is already locked, and timer
+  // cancellation is not possible.
+  bool CancelConnectFromDeadlineTimer(ConnectionState* connection_state)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(connection_state->mu);
+
+  // Completes the connection cancellation logic after checking handle validity
+  // and optionally cancelling deadline timers.
+  bool CancelConnectInternalStateLocked(ConnectionState* connection_state)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(connection_state->mu);
+
+  class TimerClosure;
   EventEngine::TaskHandle RunAfterInternal(Duration when,
                                            absl::AnyInvocable<void()> cb);
-  grpc_core::Mutex mu_;
-  TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
+  grpc_core::Mutex task_mu_;
+  TaskHandleSet known_handles_ ABSL_GUARDED_BY(task_mu_);
+  grpc_core::Mutex connection_mu_ ABSL_ACQUIRED_AFTER(ConnectionState::mu);
+  grpc_core::CondVar connection_cv_;
+  ConnectionHandleSet known_connection_handles_ ABSL_GUARDED_BY(connection_mu_);
   std::atomic<intptr_t> aba_token_{0};
 
   std::shared_ptr<ThreadPool> executor_;
   IOCP iocp_;
   TimerManager timer_manager_;
+  IOCPWorkClosure iocp_worker_;
 };
 
 }  // namespace experimental
@@ -121,4 +160,4 @@ class WindowsEventEngine : public EventEngine,
 
 #endif
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H

data/src/core/lib/experiments/config.cc

@@ -30,10 +30,12 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
 #include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/no_destruct.h"
 
+#ifndef GRPC_EXPERIMENTS_ARE_FINAL
 GPR_GLOBAL_CONFIG_DEFINE_STRING(
     grpc_experiments, "",
     "List of grpc experiments to enable (or with a '-' prefix to disable).");
@@ -58,7 +60,11 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariable() {
   // Set defaults from metadata.
   Experiments experiments;
   for (size_t i = 0; i < kNumExperiments; i++) {
-    experiments.enabled[i] = g_experiment_metadata[i].default_value;
+    if (!g_forced_experiments[i].forced) {
+      experiments.enabled[i] = g_experiment_metadata[i].default_value;
+    } else {
+      experiments.enabled[i] = g_forced_experiments[i].value;
+    }
   }
   // Get the global config.
   auto experiments_str = GPR_GLOBAL_CONFIG_GET(grpc_experiments);
@@ -144,3 +150,12 @@ void ForceEnableExperiment(absl::string_view experiment, bool enable) {
 }
 
 }  // namespace grpc_core
+#else
+namespace grpc_core {
+void PrintExperimentsList() {}
+void ForceEnableExperiment(absl::string_view experiment_name, bool) {
+  Crash(absl::StrCat("ForceEnableExperiment(\"", experiment_name,
+                     "\") called in final build"));
+}
+}  // namespace grpc_core
+#endif

data/src/core/lib/experiments/config.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EXPERIMENTS_CONFIG_H
-#define GRPC_CORE_LIB_EXPERIMENTS_CONFIG_H
+#ifndef GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H
+#define GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H
 
 #include <grpc/support/port_platform.h>
 
@@ -21,12 +21,16 @@
 
 #include "absl/strings/string_view.h"
 
+// #define GRPC_EXPERIMENTS_ARE_FINAL
+
 namespace grpc_core {
 
+#ifndef GRPC_EXPERIMENTS_ARE_FINAL
 // Return true if experiment \a experiment_id is enabled.
 // Experiments are numbered by their order in the g_experiment_metadata array
 // declared in experiments.h.
 bool IsExperimentEnabled(size_t experiment_id);
+#endif
 
 // Print out a list of all experiments that are built into this binary.
 void PrintExperimentsList();
@@ -38,6 +42,12 @@ void PrintExperimentsList();
 // If this is called twice for the same experiment, both calls must agree.
 void ForceEnableExperiment(absl::string_view experiment_name, bool enable);
 
+struct ExperimentMetadata {
+  const char* name;
+  const char* description;
+  bool default_value;
+};
+
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_EXPERIMENTS_CONFIG_H
+#endif  // GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H

data/src/core/lib/experiments/experiments.cc

@@ -18,15 +18,13 @@
 
 #include "src/core/lib/experiments/experiments.h"
 
+#ifndef GRPC_EXPERIMENTS_ARE_FINAL
 namespace {
 const char* const description_tcp_frame_size_tuning =
     "If set, enables TCP to use RPC size estimation made by higher layers. TCP "
     "would not indicate completion of a read operation until a specified "
     "number of bytes have been read over the socket. Buffers are also "
     "allocated according to estimated RPC sizes.";
-const char* const description_tcp_read_chunks =
-    "Allocate only 8kb or 64kb chunks for TCP reads to reduce pressure on "
-    "malloc to recycle arbitrary large blocks.";
 const char* const description_tcp_rcv_lowat =
     "Use SO_RCVLOWAT to avoid wakeups on the read path.";
 const char* const description_peer_state_based_framing =
@@ -39,9 +37,6 @@ const char* const description_memory_pressure_controller =
     "New memory pressure controller";
 const char* const description_unconstrained_max_quota_buffer_size =
     "Discard the cap on the max free pool size for one memory allocator";
-const char* const description_new_hpack_huffman_decoder =
-    "New HPACK huffman decoder - should be much faster than the existing "
-    "implementation.";
 const char* const description_event_engine_client =
     "Use EventEngine clients instead of iomgr's grpc_tcp_client";
 const char* const description_monitoring_experiment =
@@ -51,13 +46,20 @@ const char* const description_promise_based_client_call =
     "(ie when all filters in a stack are promise based)";
 const char* const description_free_large_allocator =
     "If set, return all free bytes from a \042big\042 allocator";
+const char* const description_promise_based_server_call =
+    "If set, use the new gRPC promise based call code when it's appropriate "
+    "(ie when all filters in a stack are promise based)";
+const char* const description_transport_supplies_client_latency =
+    "If set, use the transport represented value for client latency in "
+    "opencensus";
+const char* const description_event_engine_listener =
+    "Use EventEngine listeners instead of iomgr's grpc_tcp_server";
 }  // namespace
 
 namespace grpc_core {
 
 const ExperimentMetadata g_experiment_metadata[] = {
     {"tcp_frame_size_tuning", description_tcp_frame_size_tuning, false},
-    {"tcp_read_chunks", description_tcp_read_chunks, true},
     {"tcp_rcv_lowat", description_tcp_rcv_lowat, false},
     {"peer_state_based_framing", description_peer_state_based_framing, false},
     {"flow_control_fixes", description_flow_control_fixes, true},
@@ -65,11 +67,15 @@ const ExperimentMetadata g_experiment_metadata[] = {
      false},
     {"unconstrained_max_quota_buffer_size",
      description_unconstrained_max_quota_buffer_size, false},
-    {"new_hpack_huffman_decoder", description_new_hpack_huffman_decoder, true},
     {"event_engine_client", description_event_engine_client, false},
     {"monitoring_experiment", description_monitoring_experiment, true},
     {"promise_based_client_call", description_promise_based_client_call, false},
     {"free_large_allocator", description_free_large_allocator, false},
+    {"promise_based_server_call", description_promise_based_server_call, false},
+    {"transport_supplies_client_latency",
+     description_transport_supplies_client_latency, false},
+    {"event_engine_listener", description_event_engine_listener, false},
 };
 
 }  // namespace grpc_core
+#endif