grpc 1.54.2 → 1.56.0.pre3

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

@@ -24,6 +24,7 @@
 #include <grpc/support/log_windows.h>
 
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -50,11 +51,11 @@ void DumpSliceBuffer(SliceBuffer* buffer, absl::string_view context_string) {
 WindowsEndpoint::WindowsEndpoint(
     const EventEngine::ResolvedAddress& peer_address,
     std::unique_ptr<WinSocket> socket, MemoryAllocator&& allocator,
-    const EndpointConfig& /* config */, Executor* executor,
+    const EndpointConfig& /* config */, ThreadPool* thread_pool,
     std::shared_ptr<EventEngine> engine)
     : peer_address_(peer_address),
       allocator_(std::move(allocator)),
-      executor_(executor),
+      thread_pool_(thread_pool),
       io_state_(std::make_shared<AsyncIOState>(this, std::move(socket),
                                                std::move(engine))) {
   char addr[EventEngine::ResolvedAddress::MAX_SIZE_BYTES];
@@ -100,7 +101,7 @@ absl::Status WindowsEndpoint::DoTcpRead(SliceBuffer* buffer) {
     // Data or some error was returned immediately.
     io_state_->socket->read_info()->SetResult(
         {/*wsa_error=*/wsa_error, /*bytes_read=*/bytes_read});
-    executor_->Run(&io_state_->handle_read_event);
+    thread_pool_->Run(&io_state_->handle_read_event);
     return absl::OkStatus();
   }
   // If the endpoint has already received some data, and the next call would
@@ -126,7 +127,7 @@ absl::Status WindowsEndpoint::DoTcpRead(SliceBuffer* buffer) {
 bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
                            SliceBuffer* buffer, const ReadArgs* /* args */) {
   if (io_state_->socket->IsShutdown()) {
-    executor_->Run([on_read = std::move(on_read)]() mutable {
+    thread_pool_->Run([on_read = std::move(on_read)]() mutable {
       on_read(absl::UnavailableError("Socket is shutting down."));
     });
     return false;
@@ -143,7 +144,7 @@ bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
   auto status = DoTcpRead(buffer);
   if (!status.ok()) {
     // The read could not be completed.
-    io_state_->endpoint->executor_->Run([this, status]() {
+    io_state_->endpoint->thread_pool_->Run([this, status]() {
       io_state_->handle_read_event.ExecuteCallbackAndReset(status);
     });
   }
@@ -154,7 +155,7 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
                             SliceBuffer* data, const WriteArgs* /* args */) {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p writing", this);
   if (io_state_->socket->IsShutdown()) {
-    executor_->Run([on_writable = std::move(on_writable)]() mutable {
+    thread_pool_->Run([on_writable = std::move(on_writable)]() mutable {
       on_writable(absl::UnavailableError("Socket is shutting down."));
     });
     return false;
@@ -182,7 +183,7 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
   if (status == 0) {
     if (bytes_sent == data->Length()) {
       // Write completed, exiting early
-      executor_->Run(
+      thread_pool_->Run(
           [cb = std::move(on_writable)]() mutable { cb(absl::OkStatus()); });
       return false;
     }
@@ -203,7 +204,7 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
     // then we can avoid doing an async write operation at all.
     int wsa_error = WSAGetLastError();
     if (wsa_error != WSAEWOULDBLOCK) {
-      executor_->Run([cb = std::move(on_writable), wsa_error]() mutable {
+      thread_pool_->Run([cb = std::move(on_writable), wsa_error]() mutable {
         cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
       });
       return false;
@@ -217,7 +218,7 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
   if (status != 0) {
     int wsa_error = WSAGetLastError();
     if (wsa_error != WSA_IO_PENDING) {
-      executor_->Run([cb = std::move(on_writable), wsa_error]() mutable {
+      thread_pool_->Run([cb = std::move(on_writable), wsa_error]() mutable {
         cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
       });
       return false;
@@ -319,7 +320,7 @@ void WindowsEndpoint::HandleReadClosure::Run() {
 bool WindowsEndpoint::HandleReadClosure::MaybeFinishIfDataHasAlreadyBeenRead() {
   if (last_read_buffer_.Length() > 0) {
     buffer_->Swap(last_read_buffer_);
-    io_state_->endpoint->executor_->Run(
+    io_state_->endpoint->thread_pool_->Run(
         [this]() { ExecuteCallbackAndReset(absl::OkStatus()); });
     return true;
   }

data/src/core/lib/event_engine/windows/windows_endpoint.h

@@ -19,6 +19,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
 
 namespace grpc_event_engine {
@@ -29,7 +30,7 @@ class WindowsEndpoint : public EventEngine::Endpoint {
   WindowsEndpoint(const EventEngine::ResolvedAddress& peer_address,
                   std::unique_ptr<WinSocket> socket,
                   MemoryAllocator&& allocator, const EndpointConfig& config,
-                  Executor* Executor, std::shared_ptr<EventEngine> engine);
+                  ThreadPool* thread_pool, std::shared_ptr<EventEngine> engine);
   ~WindowsEndpoint() override;
   bool Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
             const ReadArgs* args) override;
@@ -107,7 +108,7 @@ class WindowsEndpoint : public EventEngine::Endpoint {
   EventEngine::ResolvedAddress local_address_;
   std::string local_address_string_;
   MemoryAllocator allocator_;
-  Executor* executor_;
+  ThreadPool* thread_pool_;
   std::shared_ptr<AsyncIOState> io_state_;
 };
 

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

@@ -25,13 +25,14 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
+#include <grpc/support/cpu.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/thread_pool/thread_pool.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"
@@ -48,21 +49,21 @@ namespace experimental {
 
 // ---- IOCPWorkClosure ----
 
-WindowsEventEngine::IOCPWorkClosure::IOCPWorkClosure(Executor* executor,
+WindowsEventEngine::IOCPWorkClosure::IOCPWorkClosure(ThreadPool* thread_pool,
                                                      IOCP* iocp)
-    : executor_(executor), iocp_(iocp) {
-  executor_->Run(this);
+    : thread_pool_(thread_pool), iocp_(iocp) {
+  thread_pool_->Run(this);
 }
 
 void WindowsEventEngine::IOCPWorkClosure::Run() {
   auto result = iocp_->Work(std::chrono::seconds(60), [this] {
     workers_.fetch_add(1);
-    executor_->Run(this);
+    thread_pool_->Run(this);
   });
   if (result == Poller::WorkResult::kDeadlineExceeded) {
     // iocp received no messages. restart the worker
     workers_.fetch_add(1);
-    executor_->Run(this);
+    thread_pool_->Run(this);
   }
   if (workers_.fetch_sub(1) == 1) done_signal_.Notify();
 }
@@ -97,10 +98,11 @@ struct WindowsEventEngine::TimerClosure final : public EventEngine::Closure {
 };
 
 WindowsEventEngine::WindowsEventEngine()
-    : executor_(std::make_shared<ThreadPool>()),
-      iocp_(executor_.get()),
-      timer_manager_(executor_),
-      iocp_worker_(executor_.get(), &iocp_) {
+    : thread_pool_(
+          MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
+      iocp_(thread_pool_.get()),
+      timer_manager_(thread_pool_),
+      iocp_worker_(thread_pool_.get(), &iocp_) {
   WSADATA wsaData;
   int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
   GPR_ASSERT(status == 0);
@@ -140,7 +142,7 @@ WindowsEventEngine::~WindowsEventEngine() {
   iocp_.Shutdown();
   GPR_ASSERT(WSACleanup() == 0);
   timer_manager_.Shutdown();
-  executor_->Quiesce();
+  thread_pool_->Quiesce();
 }
 
 bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
@@ -167,11 +169,11 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfter(
 }
 
 void WindowsEventEngine::Run(absl::AnyInvocable<void()> closure) {
-  executor_->Run(std::move(closure));
+  thread_pool_->Run(std::move(closure));
 }
 
 void WindowsEventEngine::Run(EventEngine::Closure* closure) {
-  executor_->Run(closure);
+  thread_pool_->Run(closure);
 }
 
 EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
@@ -219,12 +221,12 @@ void WindowsEventEngine::OnConnectCompleted(
       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
+      // This code should be running in a thread pool 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(), shared_from_this());
+          cfg, thread_pool_.get(), shared_from_this());
     }
   }
   cb(std::move(endpoint));
@@ -400,8 +402,8 @@ WindowsEventEngine::CreateListener(
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
   return std::make_unique<WindowsEventEngineListener>(
       &iocp_, std::move(on_accept), std::move(on_shutdown),
-      std::move(memory_allocator_factory), shared_from_this(), executor_.get(),
-      config);
+      std::move(memory_allocator_factory), shared_from_this(),
+      thread_pool_.get(), config);
 }
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -30,7 +30,7 @@
 
 #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/thread_pool.h"
+#include "src/core/lib/event_engine/thread_pool/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"
@@ -88,11 +88,11 @@ class WindowsEventEngine : public EventEngine,
                       absl::AnyInvocable<void()> closure) override;
   bool Cancel(TaskHandle handle) override;
 
-  // Retrieve the base executor.
+  // Retrieve the base ThreadPool.
   // 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(); }
+  ThreadPool* thread_pool() { return thread_pool_.get(); }
   IOCP* poller() { return &iocp_; }
 
  private:
@@ -116,14 +116,14 @@ class WindowsEventEngine : public EventEngine,
   // A poll worker which schedules itself unless kicked
   class IOCPWorkClosure : public EventEngine::Closure {
    public:
-    explicit IOCPWorkClosure(Executor* executor, IOCP* iocp);
+    explicit IOCPWorkClosure(ThreadPool* thread_pool, IOCP* iocp);
     void Run() override;
     void WaitForShutdown();
 
    private:
     std::atomic<int> workers_{1};
     grpc_core::Notification done_signal_;
-    Executor* executor_;
+    ThreadPool* thread_pool_;
     IOCP* iocp_;
   };
 
@@ -150,7 +150,7 @@ class WindowsEventEngine : public EventEngine,
   ConnectionHandleSet known_connection_handles_ ABSL_GUARDED_BY(connection_mu_);
   std::atomic<intptr_t> aba_token_{0};
 
-  std::shared_ptr<ThreadPool> executor_;
+  std::shared_ptr<ThreadPool> thread_pool_;
   IOCP iocp_;
   TimerManager timer_manager_;
   IOCPWorkClosure iocp_worker_;

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

@@ -201,7 +201,7 @@ void WindowsEventEngineListener::SinglePortSocketListener::
       peer_address, listener_->iocp_->Watch(io_state_->accept_socket),
       listener_->memory_allocator_factory_->CreateMemoryAllocator(
           absl::StrFormat("listener endpoint %s", peer_name)),
-      listener_->config_, listener_->executor_, listener_->engine_);
+      listener_->config_, listener_->thread_pool_, listener_->engine_);
   listener_->accept_cb_(
       std::move(endpoint),
       listener_->memory_allocator_factory_->CreateMemoryAllocator(
@@ -265,12 +265,12 @@ WindowsEventEngineListener::WindowsEventEngineListener(
     IOCP* iocp, AcceptCallback accept_cb,
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory,
-    std::shared_ptr<EventEngine> engine, Executor* executor,
+    std::shared_ptr<EventEngine> engine, ThreadPool* thread_pool,
     const EndpointConfig& config)
     : iocp_(iocp),
       config_(config),
       engine_(std::move(engine)),
-      executor_(executor),
+      thread_pool_(thread_pool),
       memory_allocator_factory_(std::move(memory_allocator_factory)),
       accept_cb_(std::move(accept_cb)),
       on_shutdown_(std::move(on_shutdown)) {}

data/src/core/lib/event_engine/windows/windows_listener.h

@@ -27,6 +27,7 @@
 #include <grpc/event_engine/memory_allocator.h>
 
 #include "src/core/lib/event_engine/common_closures.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/gprpp/sync.h"
 
@@ -39,7 +40,7 @@ class WindowsEventEngineListener : public EventEngine::Listener {
       IOCP* iocp, AcceptCallback accept_cb,
       absl::AnyInvocable<void(absl::Status)> on_shutdown,
       std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory,
-      std::shared_ptr<EventEngine> engine, Executor* executor_,
+      std::shared_ptr<EventEngine> engine, ThreadPool* thread_pool_,
       const EndpointConfig& config);
   ~WindowsEventEngineListener() override;
   absl::StatusOr<int> Bind(const EventEngine::ResolvedAddress& addr) override;
@@ -136,7 +137,7 @@ class WindowsEventEngineListener : public EventEngine::Listener {
   IOCP* const iocp_;
   const EndpointConfig& config_;
   std::shared_ptr<EventEngine> engine_;
-  Executor* executor_;
+  ThreadPool* thread_pool_;
   const std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory_;
   AcceptCallback accept_cb_;
   absl::AnyInvocable<void(absl::Status)> on_shutdown_;

data/src/core/lib/event_engine/work_queue/basic_work_queue.cc

@@ -0,0 +1,63 @@
+// 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/work_queue/basic_work_queue.h"
+
+#include <utility>
+
+#include "src/core/lib/event_engine/common_closures.h"
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+bool BasicWorkQueue::Empty() const {
+  grpc_core::MutexLock lock(&mu_);
+  return q_.empty();
+}
+
+size_t BasicWorkQueue::Size() const {
+  grpc_core::MutexLock lock(&mu_);
+  return q_.size();
+}
+
+EventEngine::Closure* BasicWorkQueue::PopMostRecent() {
+  grpc_core::MutexLock lock(&mu_);
+  if (q_.empty()) return nullptr;
+  auto tmp = q_.back();
+  q_.pop_back();
+  return tmp;
+}
+
+EventEngine::Closure* BasicWorkQueue::PopOldest() {
+  grpc_core::MutexLock lock(&mu_);
+  if (q_.empty()) return nullptr;
+  auto tmp = q_.front();
+  q_.pop_front();
+  return tmp;
+}
+
+void BasicWorkQueue::Add(EventEngine::Closure* closure) {
+  grpc_core::MutexLock lock(&mu_);
+  q_.push_back(closure);
+}
+
+void BasicWorkQueue::Add(absl::AnyInvocable<void()> invocable) {
+  grpc_core::MutexLock lock(&mu_);
+  q_.push_back(SelfDeletingClosure::Create(std::move(invocable)));
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/work_queue/basic_work_queue.h

@@ -0,0 +1,71 @@
+// 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_WORK_QUEUE_BASIC_WORK_QUEUE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_BASIC_WORK_QUEUE_H
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <deque>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/work_queue/work_queue.h"
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// A basic WorkQueue implementation that guards an std::deque with a Mutex
+//
+// Implementation note: q_.back is the most recent. q_.front is the oldest. New
+// closures are added to the back.
+class BasicWorkQueue : public WorkQueue {
+ public:
+  BasicWorkQueue() = default;
+  // Returns whether the queue is empty
+  bool Empty() const override ABSL_LOCKS_EXCLUDED(mu_);
+  // Returns the size of the queue.
+  size_t Size() const override ABSL_LOCKS_EXCLUDED(mu_);
+  // Returns the most recent element from the queue, or nullptr if either empty
+  // or the queue is under contention. This is the fastest way to retrieve
+  // elements from the queue.
+  //
+  // This method may return nullptr even if the queue is not empty.
+  EventEngine::Closure* PopMostRecent() override ABSL_LOCKS_EXCLUDED(mu_);
+  // Returns the most recent element from the queue, or nullptr if either empty
+  // or the queue is under contention.
+  // This is expected to be the slower of the two ways to retrieve closures from
+  // the queue.
+  //
+  // This method may return nullptr even if the queue is not empty.
+  EventEngine::Closure* PopOldest() override ABSL_LOCKS_EXCLUDED(mu_);
+  // Adds a closure to the queue.
+  void Add(EventEngine::Closure* closure) override ABSL_LOCKS_EXCLUDED(mu_);
+  // Wraps an AnyInvocable and adds it to the the queue.
+  void Add(absl::AnyInvocable<void()> invocable) override
+      ABSL_LOCKS_EXCLUDED(mu_);
+
+ private:
+  mutable grpc_core::Mutex mu_;
+  std::deque<EventEngine::Closure*> q_ ABSL_GUARDED_BY(mu_);
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_BASIC_WORK_QUEUE_H

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

@@ -0,0 +1,62 @@
+// Copyright 2022 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_WORK_QUEUE_WORK_QUEUE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_WORK_QUEUE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// An interface for thread-safe EventEngine callback work queues.
+//
+// Implementations should be optimized for LIFO operations using PopMostRecent.
+// All methods must be guaranteed thread-safe.
+class WorkQueue {
+ public:
+  virtual ~WorkQueue() = default;
+  // Returns whether the queue is empty.
+  virtual bool Empty() const = 0;
+  // Returns the size of the queue.
+  virtual size_t Size() const = 0;
+  // Returns the most recent element from the queue. This is the fastest way to
+  // retrieve elements from the queue.
+  //
+  // Implementations are permitted to return nullptr even if the queue is not
+  // empty. This is to support potential optimizations.
+  virtual EventEngine::Closure* PopMostRecent() = 0;
+  // Returns the most recent element from the queue, or nullptr if either empty
+  // or the queue is under contention.
+  // This is expected to be the slower of the two ways to retrieve closures from
+  // the queue.
+  //
+  // Implementations are permitted to return nullptr even if the queue is not
+  // empty. This is to support potential optimizations.
+  virtual EventEngine::Closure* PopOldest() = 0;
+  // Adds a closure to the queue.
+  virtual void Add(EventEngine::Closure* closure) = 0;
+  // Wraps an AnyInvocable and adds it to the the queue.
+  virtual void Add(absl::AnyInvocable<void()> invocable) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_WORK_QUEUE_H

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

@@ -21,7 +21,9 @@
 #include <algorithm>
 #include <atomic>
 #include <string>
+#include <utility>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
@@ -48,15 +50,23 @@ struct ForcedExperiment {
 };
 ForcedExperiment g_forced_experiments[kNumExperiments];
 
-std::atomic<bool> g_loaded;
+std::atomic<bool> g_loaded(false);
+
+absl::AnyInvocable<bool(struct ExperimentMetadata)>* g_check_constraints_cb =
+    nullptr;
 
 GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariable() {
-  GPR_ASSERT(g_loaded.exchange(true, std::memory_order_relaxed) == false);
+  g_loaded.store(true, std::memory_order_relaxed);
   // Set defaults from metadata.
   Experiments experiments;
   for (size_t i = 0; i < kNumExperiments; i++) {
     if (!g_forced_experiments[i].forced) {
-      experiments.enabled[i] = g_experiment_metadata[i].default_value;
+      if (g_check_constraints_cb != nullptr) {
+        experiments.enabled[i] =
+            (*g_check_constraints_cb)(g_experiment_metadata[i]);
+      } else {
+        experiments.enabled[i] = g_experiment_metadata[i].default_value;
+      }
     } else {
       experiments.enabled[i] = g_forced_experiments[i].value;
     }
@@ -92,14 +102,23 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariable() {
   }
   return experiments;
 }
-}  // namespace
 
-bool IsExperimentEnabled(size_t experiment_id) {
+Experiments& ExperimentsSingleton() {
   // One time initialization:
-  static const NoDestruct<Experiments> experiments{
+  static NoDestruct<Experiments> experiments{
       LoadExperimentsFromConfigVariable()};
+  return *experiments;
+}
+}  // namespace
+
+void TestOnlyReloadExperimentsFromConfigVariables() {
+  ExperimentsSingleton() = LoadExperimentsFromConfigVariable();
+  PrintExperimentsList();
+}
+
+bool IsExperimentEnabled(size_t experiment_id) {
   // Normal path: just return the value;
-  return experiments->enabled[experiment_id];
+  return ExperimentsSingleton().enabled[experiment_id];
 }
 
 void PrintExperimentsList() {
@@ -142,6 +161,13 @@ void ForceEnableExperiment(absl::string_view experiment, bool enable) {
           std::string(experiment).c_str(), enable ? "enable" : "disable");
 }
 
+void RegisterExperimentConstraintsValidator(
+    absl::AnyInvocable<bool(struct ExperimentMetadata)> check_constraints_cb) {
+  g_check_constraints_cb =
+      new absl::AnyInvocable<bool(struct ExperimentMetadata)>(
+          std::move(check_constraints_cb));
+}
+
 }  // namespace grpc_core
 #else
 namespace grpc_core {
@@ -150,5 +176,10 @@ void ForceEnableExperiment(absl::string_view experiment_name, bool) {
   Crash(absl::StrCat("ForceEnableExperiment(\"", experiment_name,
                      "\") called in final build"));
 }
+
+void RegisterExperimentConstraintsValidator(
+    absl::AnyInvocable<
+        bool(struct ExperimentMetadata)> /*check_constraints_cb*/) {}
+
 }  // namespace grpc_core
 #endif

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

@@ -19,6 +19,7 @@
 
 #include <stddef.h>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/strings/string_view.h"
 
 // #define GRPC_EXPERIMENTS_ARE_FINAL
@@ -30,6 +31,12 @@ namespace grpc_core {
 // Experiments are numbered by their order in the g_experiment_metadata array
 // declared in experiments.h.
 bool IsExperimentEnabled(size_t experiment_id);
+
+// Reload experiment state from config variables.
+// Does not change ForceEnableExperiment state.
+// Expects the caller to handle global thread safety - so really only
+// appropriate for carefully written tests.
+void TestOnlyReloadExperimentsFromConfigVariables();
 #endif
 
 // Print out a list of all experiments that are built into this binary.
@@ -45,9 +52,18 @@ void ForceEnableExperiment(absl::string_view experiment_name, bool enable);
 struct ExperimentMetadata {
   const char* name;
   const char* description;
+  const char* additional_constaints;
   bool default_value;
+  bool allow_in_fuzzing_config;
 };
 
+// Register a function to be called to validate the value an experiment can
+// take subject to additional constraints.
+// The function will take the ExperimentMetadata as its argument. It will return
+// a bool value indicating the actual value the experiment should take.
+void RegisterExperimentConstraintsValidator(
+    absl::AnyInvocable<bool(struct ExperimentMetadata)> check_constraints_cb);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H