grpc 1.60.0 → 1.61.0.pre2

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

@@ -34,11 +34,11 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
 
-#include "src/core/lib/event_engine/ares_resolver.h"
 #include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/event_engine/ref_counted_dns_resolver_interface.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -141,11 +141,8 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
  public:
   class PosixDNSResolver : public EventEngine::DNSResolver {
    public:
-    PosixDNSResolver() = delete;
-#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
     explicit PosixDNSResolver(
-        grpc_core::OrphanablePtr<AresResolver> ares_resolver);
-#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
+        grpc_core::OrphanablePtr<RefCountedDNSResolverInterface> dns_resolver);
     void LookupHostname(LookupHostnameCallback on_resolve,
                         absl::string_view name,
                         absl::string_view default_port) override;
@@ -154,10 +151,8 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
     void LookupTXT(LookupTXTCallback on_resolve,
                    absl::string_view name) override;
 
-#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
    private:
-    grpc_core::OrphanablePtr<AresResolver> ares_resolver_;
-#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_TCP)
+    grpc_core::OrphanablePtr<RefCountedDNSResolverInterface> dns_resolver_;
   };
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -203,7 +198,7 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
   bool CancelConnect(ConnectionHandle handle) override;
   bool IsWorkerThread() override;
   absl::StatusOr<std::unique_ptr<DNSResolver>> GetDNSResolver(
-      const DNSResolver::ResolverOptions& options) override;
+      GRPC_UNUSED const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
   void Run(absl::AnyInvocable<void()> closure) override;
   // Caution!! The timer implementation cannot create any fds. See #20418.

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

@@ -25,6 +25,8 @@
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_replace.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
@@ -44,8 +46,6 @@
 #include <netinet/in.h>  // IWYU pragma: keep
 #include <sys/socket.h>  // IWYU pragma: keep
 #include <unistd.h>      // IWYU pragma: keep
-
-#include "absl/strings/str_cat.h"
 #endif
 
 namespace grpc_event_engine {
@@ -176,8 +176,16 @@ absl::Status PrepareSocket(const PosixTcpOptions& options,
       GRPC_FD_SERVER_LISTENER_USAGE, options));
 
   if (bind(fd, socket.addr.address(), socket.addr.size()) < 0) {
+    auto sockaddr_str = ResolvedAddressToString(socket.addr);
+    if (!sockaddr_str.ok()) {
+      gpr_log(GPR_ERROR, "Could not convert sockaddr to string: %s",
+              sockaddr_str.status().ToString().c_str());
+      sockaddr_str = "<unparsable>";
+    }
+    sockaddr_str = absl::StrReplaceAll(*sockaddr_str, {{"\0", "@"}});
     return absl::FailedPreconditionError(
-        absl::StrCat("Error in bind: ", std::strerror(errno)));
+        absl::StrCat("Error in bind for address '", *sockaddr_str,
+                     "': ", std::strerror(errno)));
   }
 
   if (listen(fd, GetMaxAcceptQueueSize()) < 0) {

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

@@ -25,6 +25,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
 #include <grpc/impl/channel_arg_names.h>
 
 #include "src/core/lib/gpr/useful.h"
@@ -75,6 +76,7 @@ int AdjustValue(int default_value, int min_value, int max_value,
   return *actual_value;
 }
 
+#ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
 // The default values for TCP_USER_TIMEOUT are currently configured to be in
 // line with the default values of KEEPALIVE_TIMEOUT as proposed in
 // https://github.com/grpc/proposal/blob/master/A18-tcp-user-timeout.md */
@@ -83,8 +85,6 @@ int kDefaultServerUserTimeoutMs = 20000;
 bool kDefaultClientUserTimeoutEnabled = false;
 bool kDefaultServerUserTimeoutEnabled = true;
 
-#ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
-
 absl::Status ErrorForFd(
     int fd, const experimental::EventEngine::ResolvedAddress& addr) {
   if (fd >= 0) return absl::OkStatus();
@@ -210,6 +210,13 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
     options.socket_mutator =
         grpc_socket_mutator_ref(static_cast<grpc_socket_mutator*>(value));
   }
+  value =
+      config.GetVoidPointer(GRPC_ARG_EVENT_ENGINE_USE_MEMORY_ALLOCATOR_FACTORY);
+  if (value != nullptr) {
+    options.memory_allocator_factory =
+        static_cast<grpc_event_engine::experimental::MemoryAllocatorFactory*>(
+            value);
+  }
   return options;
 }
 

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

@@ -26,6 +26,7 @@
 
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 
@@ -75,6 +76,8 @@ struct PosixTcpOptions {
   int dscp = kDscpNotSet;
   grpc_core::RefCountedPtr<grpc_core::ResourceQuota> resource_quota;
   struct grpc_socket_mutator* socket_mutator = nullptr;
+  grpc_event_engine::experimental::MemoryAllocatorFactory*
+      memory_allocator_factory = nullptr;
   PosixTcpOptions() = default;
   // Move ctor
   PosixTcpOptions(PosixTcpOptions&& other) noexcept {
@@ -89,6 +92,8 @@ struct PosixTcpOptions {
     }
     socket_mutator = std::exchange(other.socket_mutator, nullptr);
     resource_quota = std::move(other.resource_quota);
+    memory_allocator_factory =
+        std::exchange(other.memory_allocator_factory, nullptr);
     CopyIntegerOptions(other);
     return *this;
   }
@@ -98,6 +103,7 @@ struct PosixTcpOptions {
       socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
     }
     resource_quota = other.resource_quota;
+    memory_allocator_factory = other.memory_allocator_factory;
     CopyIntegerOptions(other);
   }
   // Copy assignment
@@ -113,6 +119,7 @@ struct PosixTcpOptions {
       socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
     }
     resource_quota = other.resource_quota;
+    memory_allocator_factory = other.memory_allocator_factory;
     CopyIntegerOptions(other);
     return *this;
   }

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

@@ -30,7 +30,6 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/thd.h"
 
 static thread_local bool g_timer_thread;
 
@@ -67,41 +66,32 @@ bool TimerManager::WaitUntil(grpc_core::Timestamp next) {
 }
 
 void TimerManager::MainLoop() {
-  for (;;) {
-    grpc_core::Timestamp next = grpc_core::Timestamp::InfFuture();
-    absl::optional<std::vector<experimental::EventEngine::Closure*>>
-        check_result = timer_list_->TimerCheck(&next);
-    GPR_ASSERT(check_result.has_value() &&
-               "ERROR: More than one MainLoop is running.");
-    if (!check_result->empty()) {
-      RunSomeTimers(std::move(*check_result));
-      continue;
-    }
-    if (!WaitUntil(next)) break;
+  grpc_core::Timestamp next = grpc_core::Timestamp::InfFuture();
+  absl::optional<std::vector<experimental::EventEngine::Closure*>>
+      check_result = timer_list_->TimerCheck(&next);
+  GPR_ASSERT(check_result.has_value() &&
+             "ERROR: More than one MainLoop is running.");
+  bool timers_found = !check_result->empty();
+  if (timers_found) {
+    RunSomeTimers(std::move(*check_result));
   }
-  main_loop_exit_signal_->Notify();
+  thread_pool_->Run([this, next, timers_found]() {
+    if (!timers_found && !WaitUntil(next)) {
+      main_loop_exit_signal_->Notify();
+      return;
+    }
+    MainLoop();
+  });
 }
 
 bool TimerManager::IsTimerManagerThread() { return g_timer_thread; }
 
-void TimerManager::StartMainLoopThread() {
-  main_thread_ = grpc_core::Thread(
-      "timer_manager",
-      [](void* arg) {
-        auto self = static_cast<TimerManager*>(arg);
-        self->MainLoop();
-      },
-      this, nullptr,
-      grpc_core::Thread::Options().set_tracked(false).set_joinable(false));
-  main_thread_.Start();
-}
-
 TimerManager::TimerManager(
     std::shared_ptr<grpc_event_engine::experimental::ThreadPool> thread_pool)
     : host_(this), thread_pool_(std::move(thread_pool)) {
   timer_list_ = std::make_unique<TimerList>(&host_);
   main_loop_exit_signal_.emplace();
-  StartMainLoopThread();
+  thread_pool_->Run([this]() { MainLoop(); });
 }
 
 grpc_core::Timestamp TimerManager::Host::Now() {
@@ -162,7 +152,7 @@ void TimerManager::RestartPostFork() {
   }
   shutdown_ = false;
   main_loop_exit_signal_.emplace();
-  StartMainLoopThread();
+  thread_pool_->Run([this]() { MainLoop(); });
 }
 
 void TimerManager::PrepareFork() { Shutdown(); }

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

@@ -36,7 +36,6 @@
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/gprpp/notification.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/gprpp/time.h"
 
 namespace grpc_event_engine {
@@ -80,7 +79,6 @@ class TimerManager final : public grpc_event_engine::experimental::Forkable {
     TimerManager* const timer_manager_;
   };
 
-  void StartMainLoopThread();
   void RestartPostFork();
   void MainLoop();
   void RunSomeTimers(std::vector<experimental::EventEngine::Closure*> timers);
@@ -103,7 +101,6 @@ class TimerManager final : public grpc_event_engine::experimental::Forkable {
   uint64_t wakeups_ ABSL_GUARDED_BY(mu_) = false;
   // actual timer implementation
   std::unique_ptr<TimerList> timer_list_;
-  grpc_core::Thread main_thread_;
   std::shared_ptr<grpc_event_engine::experimental::ThreadPool> thread_pool_;
   absl::optional<grpc_core::Notification> main_loop_exit_signal_;
 };

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

@@ -0,0 +1,55 @@
+// 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_REF_COUNTED_DNS_RESOLVER_INTERFACE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_REF_COUNTED_DNS_RESOLVER_INTERFACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/gprpp/orphanable.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class RefCountedDNSResolverInterface
+    : public grpc_core::InternallyRefCounted<RefCountedDNSResolverInterface> {
+ public:
+  explicit RefCountedDNSResolverInterface(const char* trace = nullptr,
+                                          intptr_t initial_refcount = 1)
+      : grpc_core::InternallyRefCounted<RefCountedDNSResolverInterface>(
+            trace, initial_refcount) {}
+
+  virtual void LookupHostname(
+      EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
+      absl::string_view name, absl::string_view default_port) = 0;
+
+  virtual void LookupSRV(
+      EventEngine::DNSResolver::LookupSRVCallback on_resolved,
+      absl::string_view name) = 0;
+
+  virtual void LookupTXT(
+      EventEngine::DNSResolver::LookupTXTCallback on_resolved,
+      absl::string_view name) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_REF_COUNTED_DNS_RESOLVER_INTERFACE_H

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

@@ -0,0 +1,114 @@
+// Copyright 2024 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>
+
+#ifdef GPR_WINDOWS
+#include <inttypes.h>
+#include <string.h>
+#include <sys/types.h>
+
+#include <string>
+
+#include "absl/strings/str_format.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/windows/native_windows_dns_resolver.h"
+#include "src/core/lib/gprpp/host_port.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/iomgr/error.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
+LookupHostnameBlocking(absl::string_view name, absl::string_view default_port) {
+  std::vector<EventEngine::ResolvedAddress> addresses;
+  // parse name, splitting it into host and port parts
+  std::string host;
+  std::string port;
+  grpc_core::SplitHostPort(name, &host, &port);
+  if (host.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat("Unparseable name: ", name));
+  }
+  if (port.empty()) {
+    if (default_port.empty()) {
+      return absl::InvalidArgumentError(
+          absl::StrFormat("No port in name %s or default_port argument", name));
+    }
+    port = std::string(default_port);
+  }
+  // Call getaddrinfo
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;      // ipv4 or ipv6
+  hints.ai_socktype = SOCK_STREAM;  // stream socket
+  hints.ai_flags = AI_PASSIVE;      // for wildcard IP address
+  struct addrinfo* result = nullptr;
+  int getaddrinfo_error =
+      getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
+  if (getaddrinfo_error != 0) {
+    return absl::UnknownError(
+        absl::StrFormat("Address lookup failed for %s os_error: %s", name,
+                        grpc_core::StatusToString(
+                            GRPC_WSA_ERROR(WSAGetLastError(), "getaddrinfo"))
+                            .c_str()));
+  }
+  // Success path: collect and return all addresses
+  for (auto* resp = result; resp != nullptr; resp = resp->ai_next) {
+    addresses.emplace_back(resp->ai_addr, resp->ai_addrlen);
+  }
+  if (result) freeaddrinfo(result);
+  return addresses;
+}
+
+}  // namespace
+NativeWindowsDNSResolver::NativeWindowsDNSResolver(
+    std::shared_ptr<EventEngine> event_engine)
+    : event_engine_(std::move(event_engine)) {}
+
+void NativeWindowsDNSResolver::LookupHostname(
+    EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
+    absl::string_view name, absl::string_view default_port) {
+  event_engine_->Run(
+      [name, default_port, on_resolved = std::move(on_resolved)]() mutable {
+        on_resolved(LookupHostnameBlocking(name, default_port));
+      });
+}
+
+void NativeWindowsDNSResolver::LookupSRV(
+    EventEngine::DNSResolver::LookupSRVCallback on_resolved,
+    absl::string_view /* name */) {
+  // Not supported
+  event_engine_->Run([on_resolved = std::move(on_resolved)]() mutable {
+    on_resolved(absl::UnimplementedError(
+        "The Native resolver does not support looking up SRV records"));
+  });
+}
+
+void NativeWindowsDNSResolver::LookupTXT(
+    EventEngine::DNSResolver::LookupTXTCallback on_resolved,
+    absl::string_view /* name */) {
+  // Not supported
+  event_engine_->Run([on_resolved = std::move(on_resolved)]() mutable {
+    on_resolved(absl::UnimplementedError(
+        "The Native resolver does not support looking up TXT records"));
+  });
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_WINDOWS

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

@@ -0,0 +1,51 @@
+// Copyright 2024 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_WINDOWS_NATIVE_WINDOWS_DNS_RESOLVER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_NATIVE_WINDOWS_DNS_RESOLVER_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// An asynchronous DNS resolver which uses the native platform's getaddrinfo
+// API. Only supports A/AAAA records.
+class NativeWindowsDNSResolver : public EventEngine::DNSResolver {
+ public:
+  explicit NativeWindowsDNSResolver(std::shared_ptr<EventEngine> event_engine);
+
+  void LookupHostname(
+      EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
+      absl::string_view name, absl::string_view default_port) override;
+
+  void LookupSRV(EventEngine::DNSResolver::LookupSRVCallback on_resolved,
+                 absl::string_view name) override;
+
+  void LookupTXT(EventEngine::DNSResolver::LookupTXTCallback on_resolved,
+                 absl::string_view name) override;
+
+ private:
+  std::shared_ptr<EventEngine> event_engine_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_NATIVE_WINDOWS_DNS_RESOLVER_H

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

@@ -37,6 +37,7 @@
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/event_engine/windows/grpc_polled_fd_windows.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
+#include "src/core/lib/event_engine/windows/native_windows_dns_resolver.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/event_engine/windows/windows_listener.h"
@@ -204,17 +205,17 @@ WindowsEventEngine::WindowsDNSResolver::WindowsDNSResolver(
 void WindowsEventEngine::WindowsDNSResolver::LookupHostname(
     LookupHostnameCallback on_resolve, absl::string_view name,
     absl::string_view default_port) {
-  ares_resolver_->LookupHostname(name, default_port, std::move(on_resolve));
+  ares_resolver_->LookupHostname(std::move(on_resolve), name, default_port);
 }
 
 void WindowsEventEngine::WindowsDNSResolver::LookupSRV(
     LookupSRVCallback on_resolve, absl::string_view name) {
-  ares_resolver_->LookupSRV(name, std::move(on_resolve));
+  ares_resolver_->LookupSRV(std::move(on_resolve), name);
 }
 
 void WindowsEventEngine::WindowsDNSResolver::LookupTXT(
     LookupTXTCallback on_resolve, absl::string_view name) {
-  ares_resolver_->LookupTXT(name, std::move(on_resolve));
+  ares_resolver_->LookupTXT(std::move(on_resolve), name);
 }
 
 #endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
@@ -233,10 +234,9 @@ WindowsEventEngine::GetDNSResolver(
   return std::make_unique<WindowsEventEngine::WindowsDNSResolver>(
       std::move(*ares_resolver));
 #else   // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
-  // TODO(yijiem): Implement a basic A/AAAA-only native resolver in
-  // WindowsEventEngine.
-  (void)options;
-  grpc_core::Crash("unimplemented");
+  GRPC_EVENT_ENGINE_DNS_TRACE(
+      "WindowsEventEngine:%p creating NativeWindowsDNSResolver", this);
+  return std::make_unique<NativeWindowsDNSResolver>(shared_from_this());
 #endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
 }
 

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

@@ -135,6 +135,19 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariable() {
               std::string(experiment).c_str());
     }
   }
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    // If required experiments are not enabled, disable this one too.
+    for (size_t j = 0; j < g_experiment_metadata[i].num_required_experiments;
+         j++) {
+      // Require that we can check dependent requirements with a linear sweep
+      // (implies the experiments generator must DAG sort the experiments)
+      GPR_ASSERT(g_experiment_metadata[i].required_experiments[j] < i);
+      if (!experiments
+               .enabled[g_experiment_metadata[i].required_experiments[j]]) {
+        experiments.enabled[i] = false;
+      }
+    }
+  }
   return experiments;
 }
 

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

@@ -18,6 +18,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
+#include <stdint.h>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/strings/string_view.h"
@@ -30,6 +31,8 @@ struct ExperimentMetadata {
   const char* name;
   const char* description;
   const char* additional_constaints;
+  const uint8_t* required_experiments;
+  uint8_t num_required_experiments;
   bool default_value;
   bool allow_in_fuzzing_config;
 };