grpc 1.56.2 → 1.58.0

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

@@ -55,9 +55,8 @@ WindowsEndpoint::WindowsEndpoint(
     std::shared_ptr<EventEngine> engine)
     : peer_address_(peer_address),
       allocator_(std::move(allocator)),
-      thread_pool_(thread_pool),
-      io_state_(std::make_shared<AsyncIOState>(this, std::move(socket),
-                                               std::move(engine))) {
+      io_state_(std::make_shared<AsyncIOState>(
+          this, std::move(socket), std::move(engine), thread_pool)) {
   char addr[EventEngine::ResolvedAddress::MAX_SIZE_BYTES];
   int addr_len = sizeof(addr);
   if (getsockname(io_state_->socket->raw_socket(),
@@ -77,9 +76,9 @@ WindowsEndpoint::~WindowsEndpoint() {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("~WindowsEndpoint::%p", this);
 }
 
-absl::Status WindowsEndpoint::DoTcpRead(SliceBuffer* buffer) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p reading", this);
-  if (io_state_->socket->IsShutdown()) {
+absl::Status WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p reading", endpoint);
+  if (socket->IsShutdown()) {
     return absl::UnavailableError("Socket is shutting down.");
   }
   // Prepare the WSABUF struct
@@ -94,25 +93,25 @@ absl::Status WindowsEndpoint::DoTcpRead(SliceBuffer* buffer) {
   DWORD flags = 0;
   // First try a synchronous, non-blocking read.
   int status =
-      WSARecv(io_state_->socket->raw_socket(), wsa_buffers,
-              (DWORD)buffer->Count(), &bytes_read, &flags, nullptr, nullptr);
+      WSARecv(socket->raw_socket(), wsa_buffers, (DWORD)buffer->Count(),
+              &bytes_read, &flags, nullptr, nullptr);
   int wsa_error = status == 0 ? 0 : WSAGetLastError();
   if (wsa_error != WSAEWOULDBLOCK) {
     // Data or some error was returned immediately.
-    io_state_->socket->read_info()->SetResult(
+    socket->read_info()->SetResult(
         {/*wsa_error=*/wsa_error, /*bytes_read=*/bytes_read});
-    thread_pool_->Run(&io_state_->handle_read_event);
+    thread_pool->Run(&handle_read_event);
     return absl::OkStatus();
   }
   // If the endpoint has already received some data, and the next call would
   // block, return the data in case that is all the data the reader expects.
-  if (io_state_->handle_read_event.MaybeFinishIfDataHasAlreadyBeenRead()) {
+  if (handle_read_event.MaybeFinishIfDataHasAlreadyBeenRead()) {
     return absl::OkStatus();
   }
   // Otherwise, let's retry, by queuing a read.
-  status = WSARecv(io_state_->socket->raw_socket(), wsa_buffers,
-                   (DWORD)buffer->Count(), &bytes_read, &flags,
-                   io_state_->socket->read_info()->overlapped(), nullptr);
+  status =
+      WSARecv(socket->raw_socket(), wsa_buffers, (DWORD)buffer->Count(),
+              &bytes_read, &flags, socket->read_info()->overlapped(), nullptr);
   wsa_error = status == 0 ? 0 : WSAGetLastError();
   if (wsa_error != 0 && wsa_error != WSA_IO_PENDING) {
     // Async read returned immediately with an error
@@ -120,14 +119,14 @@ absl::Status WindowsEndpoint::DoTcpRead(SliceBuffer* buffer) {
         wsa_error,
         absl::StrFormat("WindowsEndpont::%p Read failed", this).c_str());
   }
-  io_state_->socket->NotifyOnRead(&io_state_->handle_read_event);
+  socket->NotifyOnRead(&handle_read_event);
   return absl::OkStatus();
 }
 
 bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
                            SliceBuffer* buffer, const ReadArgs* /* args */) {
   if (io_state_->socket->IsShutdown()) {
-    thread_pool_->Run([on_read = std::move(on_read)]() mutable {
+    io_state_->thread_pool->Run([on_read = std::move(on_read)]() mutable {
       on_read(absl::UnavailableError("Socket is shutting down."));
     });
     return false;
@@ -141,12 +140,12 @@ bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
     buffer->AppendIndexed(Slice(allocator_.MakeSlice(min_read_size)));
   }
   io_state_->handle_read_event.Prime(io_state_, buffer, std::move(on_read));
-  auto status = DoTcpRead(buffer);
+  auto status = io_state_->DoTcpRead(buffer);
   if (!status.ok()) {
     // The read could not be completed.
-    io_state_->endpoint->thread_pool_->Run([this, status]() {
-      io_state_->handle_read_event.ExecuteCallbackAndReset(status);
-    });
+    io_state_->thread_pool->Run(
+        [cb = io_state_->handle_read_event.ResetAndReturnCallback(),
+         status]() mutable { cb(status); });
   }
   return false;
 }
@@ -155,9 +154,10 @@ 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()) {
-    thread_pool_->Run([on_writable = std::move(on_writable)]() mutable {
-      on_writable(absl::UnavailableError("Socket is shutting down."));
-    });
+    io_state_->thread_pool->Run(
+        [on_writable = std::move(on_writable)]() mutable {
+          on_writable(absl::UnavailableError("Socket is shutting down."));
+        });
     return false;
   }
   if (grpc_event_engine_endpoint_data_trace.enabled()) {
@@ -183,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
-      thread_pool_->Run(
+      io_state_->thread_pool->Run(
           [cb = std::move(on_writable)]() mutable { cb(absl::OkStatus()); });
       return false;
     }
@@ -204,9 +204,10 @@ 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) {
-      thread_pool_->Run([cb = std::move(on_writable), wsa_error]() mutable {
-        cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
-      });
+      io_state_->thread_pool->Run(
+          [cb = std::move(on_writable), wsa_error]() mutable {
+            cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
+          });
       return false;
     }
   }
@@ -218,9 +219,10 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
   if (status != 0) {
     int wsa_error = WSAGetLastError();
     if (wsa_error != WSA_IO_PENDING) {
-      thread_pool_->Run([cb = std::move(on_writable), wsa_error]() mutable {
-        cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
-      });
+      io_state_->thread_pool->Run(
+          [cb = std::move(on_writable), wsa_error]() mutable {
+            cb(GRPC_WSA_ERROR(wsa_error, "WSASend"));
+          });
       return false;
     }
   }
@@ -246,16 +248,22 @@ void AbortOnEvent(absl::Status) {
 }
 }  // namespace
 
-void WindowsEndpoint::HandleReadClosure::Reset() {
-  io_state_.reset();
+absl::AnyInvocable<void(absl::Status)>
+WindowsEndpoint::HandleReadClosure::ResetAndReturnCallback() {
+  auto cb = std::move(cb_);
   cb_ = &AbortOnEvent;
   buffer_ = nullptr;
+  io_state_.reset();
+  return cb;
 }
 
-void WindowsEndpoint::HandleWriteClosure::Reset() {
-  io_state_.reset();
+absl::AnyInvocable<void(absl::Status)>
+WindowsEndpoint::HandleWriteClosure::ResetAndReturnCallback() {
+  auto cb = std::move(cb_);
   cb_ = &AbortOnEvent;
   buffer_ = nullptr;
+  io_state_.reset();
+  return cb;
 }
 
 void WindowsEndpoint::HandleReadClosure::Prime(
@@ -276,6 +284,7 @@ void WindowsEndpoint::HandleWriteClosure::Prime(
 
 void WindowsEndpoint::HandleReadClosure::Run() {
   // Deletes the shared_ptr when this closure returns
+  // Note that the endpoint may have already been destroyed.
   auto io_state = std::move(io_state_);
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Read Event",
                                    io_state->endpoint);
@@ -284,21 +293,19 @@ void WindowsEndpoint::HandleReadClosure::Run() {
   if (result.wsa_error != 0) {
     status = GRPC_WSA_ERROR(result.wsa_error, "Async Read Error");
     buffer_->Clear();
-    return ExecuteCallbackAndReset(status);
+    return ResetAndReturnCallback()(status);
   }
   if (result.bytes_transferred == 0) {
     // Either the endpoint is shut down or we've seen the end of the stream
     if (grpc_event_engine_endpoint_data_trace.enabled()) {
-      DumpSliceBuffer(
-          buffer_, absl::StrFormat("WindowsEndpoint::%p READ (peer=%s)",
-                                   io_state->endpoint,
-                                   io_state->endpoint->peer_address_string_));
+      DumpSliceBuffer(buffer_, absl::StrFormat("WindowsEndpoint::%p READ",
+                                               io_state->endpoint));
     }
     status = absl::UnavailableError("End of TCP stream");
     grpc_core::StatusSetInt(&status, grpc_core::StatusIntProperty::kRpcStatus,
                             GRPC_STATUS_UNAVAILABLE);
     buffer_->Swap(last_read_buffer_);
-    return ExecuteCallbackAndReset(status);
+    return ResetAndReturnCallback()(status);
   }
   GPR_DEBUG_ASSERT(result.bytes_transferred > 0);
   GPR_DEBUG_ASSERT(result.bytes_transferred <= buffer_->Length());
@@ -306,34 +313,27 @@ void WindowsEndpoint::HandleReadClosure::Run() {
                                           last_read_buffer_);
   if (buffer_->Length() == 0) {
     buffer_->Swap(last_read_buffer_);
-    return ExecuteCallbackAndReset(status);
+    return ResetAndReturnCallback()(status);
   }
   // Doing another read. Let's keep the AsyncIOState alive a bit longer.
   io_state_ = std::move(io_state);
-  status = io_state_->endpoint->DoTcpRead(buffer_);
+  status = io_state_->DoTcpRead(buffer_);
   if (!status.ok()) {
-    io_state_.reset();
-    ExecuteCallbackAndReset(status);
+    return ResetAndReturnCallback()(status);
   }
 }
 
 bool WindowsEndpoint::HandleReadClosure::MaybeFinishIfDataHasAlreadyBeenRead() {
   if (last_read_buffer_.Length() > 0) {
     buffer_->Swap(last_read_buffer_);
-    io_state_->endpoint->thread_pool_->Run(
-        [this]() { ExecuteCallbackAndReset(absl::OkStatus()); });
+    // Captures io_state_ to ensure it remains alive until the callback is run.
+    io_state_->thread_pool->Run(
+        [cb = ResetAndReturnCallback()]() mutable { cb(absl::OkStatus()); });
     return true;
   }
   return false;
 }
 
-void WindowsEndpoint::HandleReadClosure::ExecuteCallbackAndReset(
-    absl::Status status) {
-  auto cb = std::move(cb_);
-  Reset();
-  cb(status);
-}
-
 void WindowsEndpoint::HandleReadClosure::DonateSpareSlices(
     SliceBuffer* buffer) {
   // Donee buffer must be empty.
@@ -348,7 +348,6 @@ void WindowsEndpoint::HandleWriteClosure::Run() {
   auto io_state = std::move(io_state_);
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Write Event",
                                    io_state->endpoint);
-  auto cb = std::move(cb_);
   const auto result = io_state->socket->write_info()->result();
   absl::Status status;
   if (result.wsa_error != 0) {
@@ -356,18 +355,19 @@ void WindowsEndpoint::HandleWriteClosure::Run() {
   } else {
     GPR_ASSERT(result.bytes_transferred == buffer_->Length());
   }
-  Reset();
-  cb(status);
+  return ResetAndReturnCallback()(status);
 }
 
 // ---- AsyncIOState ----
 
 WindowsEndpoint::AsyncIOState::AsyncIOState(WindowsEndpoint* endpoint,
                                             std::unique_ptr<WinSocket> socket,
-                                            std::shared_ptr<EventEngine> engine)
+                                            std::shared_ptr<EventEngine> engine,
+                                            ThreadPool* thread_pool)
     : endpoint(endpoint),
       socket(std::move(socket)),
-      engine(std::move(engine)) {}
+      engine(std::move(engine)),
+      thread_pool(thread_pool) {}
 
 WindowsEndpoint::AsyncIOState::~AsyncIOState() {
   socket->Shutdown(DEBUG_LOCATION, "~AsyncIOState");

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

@@ -48,15 +48,15 @@ class WindowsEndpoint : public EventEngine::Endpoint {
     void Run() override;
     void Prime(std::shared_ptr<AsyncIOState> io_state, SliceBuffer* buffer,
                absl::AnyInvocable<void(absl::Status)> cb);
-    // Resets the per-request data
-    void Reset();
+    // Resets the per-request data, releasing the ref on io_state_.
+    // Returns the previous callback.
+    ABSL_MUST_USE_RESULT absl::AnyInvocable<void(absl::Status)>
+    ResetAndReturnCallback();
     // Run the callback with whatever data is available, and reset state.
     //
     // Returns true if the callback has been called with some data. Returns
     // false if no data has been read.
     bool MaybeFinishIfDataHasAlreadyBeenRead();
-    // Execute the callback and reset.
-    void ExecuteCallbackAndReset(absl::Status status);
     // Swap any leftover slices into the provided buffer
     void DonateSpareSlices(SliceBuffer* buffer);
 
@@ -73,8 +73,10 @@ class WindowsEndpoint : public EventEngine::Endpoint {
     void Run() override;
     void Prime(std::shared_ptr<AsyncIOState> io_state, SliceBuffer* buffer,
                absl::AnyInvocable<void(absl::Status)> cb);
-    // Resets the per-request data
-    void Reset();
+    // Resets the per-request data, releasing the ref on io_state_.
+    // Returns the previous callback.
+    ABSL_MUST_USE_RESULT absl::AnyInvocable<void(absl::Status)>
+    ResetAndReturnCallback();
 
    private:
     std::shared_ptr<AsyncIOState> io_state_;
@@ -90,25 +92,26 @@ class WindowsEndpoint : public EventEngine::Endpoint {
   // events are complete.
   struct AsyncIOState {
     AsyncIOState(WindowsEndpoint* endpoint, std::unique_ptr<WinSocket> socket,
-                 std::shared_ptr<EventEngine> engine);
+                 std::shared_ptr<EventEngine> engine, ThreadPool* thread_pool);
     ~AsyncIOState();
+
+    // Perform the low-level calls and execute the HandleReadClosure
+    // asynchronously.
+    absl::Status DoTcpRead(SliceBuffer* buffer);
+
     WindowsEndpoint* const endpoint;
     std::unique_ptr<WinSocket> socket;
     HandleReadClosure handle_read_event;
     HandleWriteClosure handle_write_event;
     std::shared_ptr<EventEngine> engine;
+    ThreadPool* thread_pool;
   };
 
-  // Perform the low-level calls and execute the HandleReadClosure
-  // asynchronously.
-  absl::Status DoTcpRead(SliceBuffer* buffer);
-
   EventEngine::ResolvedAddress peer_address_;
   std::string peer_address_string_;
   EventEngine::ResolvedAddress local_address_;
   std::string local_address_string_;
   MemoryAllocator allocator_;
-  ThreadPool* thread_pool_;
   std::shared_ptr<AsyncIOState> io_state_;
 };
 

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

@@ -194,7 +194,8 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
   return handle;
 }
 
-std::unique_ptr<EventEngine::DNSResolver> WindowsEventEngine::GetDNSResolver(
+absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
+WindowsEventEngine::GetDNSResolver(
     EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
   grpc_core::Crash("unimplemented");
 }

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

@@ -48,17 +48,13 @@ class WindowsEventEngine : public EventEngine,
   class WindowsDNSResolver : public EventEngine::DNSResolver {
    public:
     ~WindowsDNSResolver() override;
-    LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
-                                    absl::string_view name,
-                                    absl::string_view default_port,
-                                    Duration timeout) override;
-    LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
-                               absl::string_view name,
-                               Duration timeout) override;
-    LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
-                               absl::string_view name,
-                               Duration timeout) override;
-    bool CancelLookup(LookupTaskHandle handle) override;
+    void LookupHostname(LookupHostnameCallback on_resolve,
+                        absl::string_view name,
+                        absl::string_view default_port) override;
+    void LookupSRV(LookupSRVCallback on_resolve,
+                   absl::string_view name) override;
+    void LookupTXT(LookupTXTCallback on_resolve,
+                   absl::string_view name) override;
   };
 
   WindowsEventEngine();
@@ -79,7 +75,7 @@ class WindowsEventEngine : public EventEngine,
 
   bool CancelConnect(ConnectionHandle handle) override;
   bool IsWorkerThread() override;
-  std::unique_ptr<DNSResolver> GetDNSResolver(
+  absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
       const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
   void Run(absl::AnyInvocable<void()> closure) override;

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

@@ -24,10 +24,10 @@
 #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"
 #include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
 
 #include <grpc/support/log.h>
 
@@ -55,6 +55,44 @@ std::atomic<bool> g_loaded(false);
 absl::AnyInvocable<bool(struct ExperimentMetadata)>* g_check_constraints_cb =
     nullptr;
 
+class TestExperiments {
+ public:
+  TestExperiments(const ExperimentMetadata* experiment_metadata,
+                  size_t num_experiments) {
+    enabled_ = new bool[num_experiments];
+    for (size_t i = 0; i < num_experiments; i++) {
+      if (g_check_constraints_cb != nullptr) {
+        enabled_[i] = (*g_check_constraints_cb)(experiment_metadata[i]);
+      } else {
+        enabled_[i] = experiment_metadata[i].default_value;
+      }
+    }
+    // For each comma-separated experiment in the global config:
+    for (auto experiment : absl::StrSplit(ConfigVars::Get().Experiments(), ',',
+                                          absl::SkipWhitespace())) {
+      // Enable unless prefixed with '-' (=> disable).
+      bool enable = !absl::ConsumePrefix(&experiment, "-");
+      // See if we can find the experiment in the list in this binary.
+      for (size_t i = 0; i < num_experiments; i++) {
+        if (experiment == experiment_metadata[i].name) {
+          enabled_[i] = enable;
+          break;
+        }
+      }
+    }
+  }
+
+  // Overloading [] operator to access elements in array style
+  bool operator[](int index) { return enabled_[index]; }
+
+  ~TestExperiments() { delete enabled_; }
+
+ private:
+  bool* enabled_;
+};
+
+TestExperiments* g_test_experiments = nullptr;
+
 GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariable() {
   g_loaded.store(true, std::memory_order_relaxed);
   // Set defaults from metadata.
@@ -72,12 +110,8 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariable() {
     }
   }
   // For each comma-separated experiment in the global config:
-  for (auto experiment : absl::StrSplit(
-           absl::string_view(ConfigVars::Get().Experiments()), ',')) {
-    // Strip whitespace.
-    experiment = absl::StripAsciiWhitespace(experiment);
-    // Handle ",," without crashing.
-    if (experiment.empty()) continue;
+  for (auto experiment : absl::StrSplit(ConfigVars::Get().Experiments(), ',',
+                                        absl::SkipWhitespace())) {
     // Enable unless prefixed with '-' (=> disable).
     bool enable = true;
     if (experiment[0] == '-') {
@@ -116,11 +150,20 @@ void TestOnlyReloadExperimentsFromConfigVariables() {
   PrintExperimentsList();
 }
 
+void LoadTestOnlyExperimentsFromMetadata(
+    const ExperimentMetadata* experiment_metadata, size_t num_experiments) {
+  g_test_experiments =
+      new TestExperiments(experiment_metadata, num_experiments);
+}
+
 bool IsExperimentEnabled(size_t experiment_id) {
-  // Normal path: just return the value;
   return ExperimentsSingleton().enabled[experiment_id];
 }
 
+bool IsTestExperimentEnabled(size_t experiment_id) {
+  return (*g_test_experiments)[experiment_id];
+}
+
 void PrintExperimentsList() {
   size_t max_experiment_length = 0;
   for (size_t i = 0; i < kNumExperiments; i++) {
@@ -128,20 +171,29 @@ void PrintExperimentsList() {
         std::max(max_experiment_length, strlen(g_experiment_metadata[i].name));
   }
   for (size_t i = 0; i < kNumExperiments; i++) {
-    gpr_log(GPR_DEBUG, "%s",
-            absl::StrCat(
-                "gRPC EXPERIMENT ", g_experiment_metadata[i].name,
-                std::string(max_experiment_length -
-                                strlen(g_experiment_metadata[i].name) + 1,
-                            ' '),
-                IsExperimentEnabled(i) ? "ON " : "OFF", " (default:",
-                g_experiment_metadata[i].default_value ? "ON" : "OFF",
-                g_forced_experiments[i].forced
-                    ? absl::StrCat(" force:",
-                                   g_forced_experiments[i].value ? "ON" : "OFF")
-                    : std::string(),
-                ")")
-                .c_str());
+    gpr_log(
+        GPR_DEBUG, "%s",
+        absl::StrCat(
+            "gRPC EXPERIMENT ", g_experiment_metadata[i].name,
+            std::string(max_experiment_length -
+                            strlen(g_experiment_metadata[i].name) + 1,
+                        ' '),
+            IsExperimentEnabled(i) ? "ON " : "OFF",
+            " (default:", g_experiment_metadata[i].default_value ? "ON" : "OFF",
+            (g_check_constraints_cb != nullptr
+                 ? absl::StrCat(
+                       " + ", g_experiment_metadata[i].additional_constaints,
+                       " => ",
+                       (*g_check_constraints_cb)(g_experiment_metadata[i])
+                           ? "ON "
+                           : "OFF")
+                 : std::string()),
+            g_forced_experiments[i].forced
+                ? absl::StrCat(" force:",
+                               g_forced_experiments[i].value ? "ON" : "OFF")
+                : std::string(),
+            ")")
+            .c_str());
   }
 }
 

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

@@ -26,17 +26,37 @@
 
 namespace grpc_core {
 
+struct ExperimentMetadata {
+  const char* name;
+  const char* description;
+  const char* additional_constaints;
+  bool default_value;
+  bool allow_in_fuzzing_config;
+};
+
 #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);
 
+// Given a test experiment id, returns true if the test experiment is enabled.
+// Test experiments can be loaded using the LoadTestOnlyExperimentsFromMetadata
+// method.
+bool IsTestExperimentEnabled(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();
+
+// Reload experiment state from passed metadata.
+// Does not change ForceEnableExperiment state.
+// Expects the caller to handle global thread safety - so really only
+// appropriate for carefully written tests.
+void LoadTestOnlyExperimentsFromMetadata(
+    const ExperimentMetadata* experiment_metadata, size_t num_experiments);
 #endif
 
 // Print out a list of all experiments that are built into this binary.
@@ -49,14 +69,6 @@ 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;
-  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