grpc 1.53.0 → 1.56.0

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

@@ -0,0 +1,156 @@
+// 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_WINDOWS_WINDOWS_LISTENER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_LISTENER_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include <list>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/statusor.h"
+
+#include <grpc/event_engine/event_engine.h>
+#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"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class WindowsEventEngineListener : public EventEngine::Listener {
+ public:
+  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, ThreadPool* thread_pool_,
+      const EndpointConfig& config);
+  ~WindowsEventEngineListener() override;
+  absl::StatusOr<int> Bind(const EventEngine::ResolvedAddress& addr) override;
+  absl::Status Start() override;
+  // TODO(hork): this may only be needed for the iomgr shim, to accommodate
+  // calls to grpc_tcp_server_shutdown_listeners
+  void ShutdownListeners();
+
+ private:
+  /// Responsible for listening on a single port.
+  class SinglePortSocketListener {
+   public:
+    ~SinglePortSocketListener();
+    // This factory will create a bound, listening WinSocket, registered with
+    // the listener's IOCP poller.
+    static absl::StatusOr<std::unique_ptr<SinglePortSocketListener>> Create(
+        WindowsEventEngineListener* listener, SOCKET sock,
+        EventEngine::ResolvedAddress addr);
+
+    // Two-stage initialization, allows creation of all bound sockets before the
+    // listener is started.
+    absl::Status Start();
+    absl::Status StartLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(io_state_->mu);
+
+    // Accessor methods
+    EventEngine::ResolvedAddress listener_sockname() {
+      return listener_sockname_;
+    };
+    int port() { return port_; }
+
+   private:
+    struct AsyncIOState;
+
+    class OnAcceptCallbackWrapper : public EventEngine::Closure {
+     public:
+      void Run() override;
+      void Prime(std::shared_ptr<AsyncIOState> io_state);
+
+     private:
+      std::shared_ptr<AsyncIOState> io_state_;
+    };
+
+    // A class to manage the data that must outlive the Endpoint.
+    //
+    // Once a listener is done and destroyed, there still may be overlapped
+    // operations pending. To clean up safely, this data must outlive the
+    // Listener, and be destroyed asynchronously when all pending overlapped
+    // events are complete.
+    struct AsyncIOState {
+      AsyncIOState(SinglePortSocketListener* port_listener,
+                   std::unique_ptr<WinSocket> listener_socket);
+      ~AsyncIOState();
+      SinglePortSocketListener* const port_listener;
+      OnAcceptCallbackWrapper on_accept_cb;
+      // Synchronize accept handling on the same socket.
+      grpc_core::Mutex mu;
+      // This will hold the socket for the next accept.
+      SOCKET accept_socket ABSL_GUARDED_BY(mu) = INVALID_SOCKET;
+      // The listener winsocket.
+      std::unique_ptr<WinSocket> listener_socket ABSL_GUARDED_BY(mu);
+    };
+
+    SinglePortSocketListener(WindowsEventEngineListener* listener,
+                             LPFN_ACCEPTEX AcceptEx,
+                             std::unique_ptr<WinSocket> listener_socket,
+                             int port, EventEngine::ResolvedAddress hostbyname);
+
+    // Bind a recently-created socket for listening
+    struct PrepareListenerSocketResult {
+      int port;
+      EventEngine::ResolvedAddress hostbyname;
+    };
+    static absl::StatusOr<PrepareListenerSocketResult> PrepareListenerSocket(
+        SOCKET sock, const EventEngine::ResolvedAddress& addr);
+
+    void OnAcceptCallbackLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(io_state_->mu);
+
+    // The cached AcceptEx for that port.
+    LPFN_ACCEPTEX AcceptEx;
+    // This seemingly magic number comes from AcceptEx's documentation. each
+    // address buffer needs to have at least 16 more bytes at their end.
+    uint8_t addresses_[(sizeof(sockaddr_in6) + 16) * 2] = {};
+    // The parent listener
+    WindowsEventEngineListener* listener_;
+    // shared state for asynchronous cleanup of overlapped operations
+    std::shared_ptr<AsyncIOState> io_state_;
+    // The actual TCP port number.
+    int port_;
+    EventEngine::ResolvedAddress listener_sockname_;
+  };
+  absl::StatusOr<SinglePortSocketListener*> AddSinglePortSocketListener(
+      SOCKET sock, EventEngine::ResolvedAddress addr);
+
+  IOCP* const iocp_;
+  const EndpointConfig& config_;
+  std::shared_ptr<EventEngine> engine_;
+  ThreadPool* thread_pool_;
+  const std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory_;
+  AcceptCallback accept_cb_;
+  absl::AnyInvocable<void(absl::Status)> on_shutdown_;
+  std::atomic<bool> started_{false};
+  grpc_core::Mutex port_listeners_mu_;
+  std::list<std::unique_ptr<SinglePortSocketListener>> port_listeners_
+      ABSL_GUARDED_BY(port_listeners_mu_);
+  bool listeners_shutdown_ ABSL_GUARDED_BY(port_listeners_mu_) = false;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_LISTENER_H

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"
@@ -29,17 +31,12 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/config/config_vars.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).");
-
 namespace grpc_core {
 
 namespace {
@@ -53,24 +50,30 @@ 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;
     }
   }
-  // Get the global config.
-  auto experiments_str = GPR_GLOBAL_CONFIG_GET(grpc_experiments);
   // For each comma-separated experiment in the global config:
-  for (auto experiment :
-       absl::StrSplit(absl::string_view(experiments_str.get()), ',')) {
+  for (auto experiment : absl::StrSplit(
+           absl::string_view(ConfigVars::Get().Experiments()), ',')) {
     // Strip whitespace.
     experiment = absl::StripAsciiWhitespace(experiment);
     // Handle ",," without crashing.
@@ -99,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() {
@@ -149,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 {
@@ -157,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

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

@@ -1,4 +1,4 @@
-// Copyright 2022 gRPC authors.
+// Copyright 2023 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Automatically generated by tools/codegen/core/gen_experiments.py
+// Auto generated by tools/codegen/core/gen_experiments.py
 
 #include <grpc/support/port_platform.h>
 
@@ -25,56 +25,113 @@ const char* const description_tcp_frame_size_tuning =
     "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 additional_constraints_tcp_frame_size_tuning = "{}";
 const char* const description_tcp_rcv_lowat =
     "Use SO_RCVLOWAT to avoid wakeups on the read path.";
+const char* const additional_constraints_tcp_rcv_lowat = "{}";
 const char* const description_peer_state_based_framing =
     "If set, the max sizes of frames sent to lower layers is controlled based "
     "on the peer's memory pressure which is reflected in its max http2 frame "
     "size.";
-const char* const description_flow_control_fixes =
-    "Various fixes for flow control, max frame size setting.";
+const char* const additional_constraints_peer_state_based_framing = "{}";
 const char* const description_memory_pressure_controller =
     "New memory pressure controller";
+const char* const additional_constraints_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 additional_constraints_unconstrained_max_quota_buffer_size =
+    "{}";
 const char* const description_event_engine_client =
     "Use EventEngine clients instead of iomgr's grpc_tcp_client";
+const char* const additional_constraints_event_engine_client = "{}";
 const char* const description_monitoring_experiment =
     "Placeholder experiment to prove/disprove our monitoring is working";
+const char* const additional_constraints_monitoring_experiment = "{}";
 const char* const description_promise_based_client_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 additional_constraints_promise_based_client_call = "{}";
 const char* const description_free_large_allocator =
     "If set, return all free bytes from a \042big\042 allocator";
+const char* const additional_constraints_free_large_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 additional_constraints_promise_based_server_call = "{}";
 const char* const description_transport_supplies_client_latency =
     "If set, use the transport represented value for client latency in "
     "opencensus";
+const char* const additional_constraints_transport_supplies_client_latency =
+    "{}";
 const char* const description_event_engine_listener =
     "Use EventEngine listeners instead of iomgr's grpc_tcp_server";
+const char* const additional_constraints_event_engine_listener = "{}";
+const char* const description_schedule_cancellation_over_write =
+    "Allow cancellation op to be scheduled over a write";
+const char* const additional_constraints_schedule_cancellation_over_write =
+    "{}";
+const char* const description_trace_record_callops =
+    "Enables tracing of call batch initiation and completion.";
+const char* const additional_constraints_trace_record_callops = "{}";
+const char* const description_event_engine_dns =
+    "If set, use EventEngine DNSResolver for client channel resolution";
+const char* const additional_constraints_event_engine_dns = "{}";
+const char* const description_work_stealing =
+    "If set, use a work stealing thread pool implementation in EventEngine";
+const char* const additional_constraints_work_stealing = "{}";
+const char* const description_client_privacy = "If set, client privacy";
+const char* const additional_constraints_client_privacy = "{}";
+const char* const description_canary_client_privacy =
+    "If set, canary client privacy";
+const char* const additional_constraints_canary_client_privacy = "{}";
+const char* const description_server_privacy = "If set, server privacy";
+const char* const additional_constraints_server_privacy = "{}";
 }  // namespace
 
 namespace grpc_core {
 
 const ExperimentMetadata g_experiment_metadata[] = {
-    {"tcp_frame_size_tuning", description_tcp_frame_size_tuning, false},
-    {"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},
+    {"tcp_frame_size_tuning", description_tcp_frame_size_tuning,
+     additional_constraints_tcp_frame_size_tuning, false, true},
+    {"tcp_rcv_lowat", description_tcp_rcv_lowat,
+     additional_constraints_tcp_rcv_lowat, false, true},
+    {"peer_state_based_framing", description_peer_state_based_framing,
+     additional_constraints_peer_state_based_framing, false, true},
     {"memory_pressure_controller", description_memory_pressure_controller,
-     false},
+     additional_constraints_memory_pressure_controller, false, true},
     {"unconstrained_max_quota_buffer_size",
-     description_unconstrained_max_quota_buffer_size, false},
-    {"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},
+     description_unconstrained_max_quota_buffer_size,
+     additional_constraints_unconstrained_max_quota_buffer_size, false, true},
+    {"event_engine_client", description_event_engine_client,
+     additional_constraints_event_engine_client, false, true},
+    {"monitoring_experiment", description_monitoring_experiment,
+     additional_constraints_monitoring_experiment, true, true},
+    {"promise_based_client_call", description_promise_based_client_call,
+     additional_constraints_promise_based_client_call, false, true},
+    {"free_large_allocator", description_free_large_allocator,
+     additional_constraints_free_large_allocator, false, true},
+    {"promise_based_server_call", description_promise_based_server_call,
+     additional_constraints_promise_based_server_call, false, true},
     {"transport_supplies_client_latency",
-     description_transport_supplies_client_latency, false},
-    {"event_engine_listener", description_event_engine_listener, false},
+     description_transport_supplies_client_latency,
+     additional_constraints_transport_supplies_client_latency, false, true},
+    {"event_engine_listener", description_event_engine_listener,
+     additional_constraints_event_engine_listener, false, true},
+    {"schedule_cancellation_over_write",
+     description_schedule_cancellation_over_write,
+     additional_constraints_schedule_cancellation_over_write, false, true},
+    {"trace_record_callops", description_trace_record_callops,
+     additional_constraints_trace_record_callops, false, true},
+    {"event_engine_dns", description_event_engine_dns,
+     additional_constraints_event_engine_dns, false, false},
+    {"work_stealing", description_work_stealing,
+     additional_constraints_work_stealing, false, false},
+    {"client_privacy", description_client_privacy,
+     additional_constraints_client_privacy, false, false},
+    {"canary_client_privacy", description_canary_client_privacy,
+     additional_constraints_canary_client_privacy, false, false},
+    {"server_privacy", description_server_privacy,
+     additional_constraints_server_privacy, false, false},
 };
 
 }  // namespace grpc_core