grpc 1.55.0 → 1.58.0

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,11 +21,13 @@
 #include <algorithm>
 #include <atomic>
 #include <string>
+#include <utility>
 
-#include "absl/strings/ascii.h"
+#include "absl/functional/any_invocable.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>
 
@@ -48,26 +50,68 @@ 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;
+
+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() {
-  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;
     }
   }
   // 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] == '-') {
@@ -92,14 +136,32 @@ 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()};
-  // Normal path: just return the value;
-  return experiments->enabled[experiment_id];
+  return *experiments;
+}
+}  // namespace
+
+void TestOnlyReloadExperimentsFromConfigVariables() {
+  ExperimentsSingleton() = LoadExperimentsFromConfigVariable();
+  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) {
+  return ExperimentsSingleton().enabled[experiment_id];
+}
+
+bool IsTestExperimentEnabled(size_t experiment_id) {
+  return (*g_test_experiments)[experiment_id];
 }
 
 void PrintExperimentsList() {
@@ -109,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());
   }
 }
 
@@ -142,6 +213,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 +228,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,17 +19,44 @@
 
 #include <stddef.h>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/strings/string_view.h"
 
 // #define GRPC_EXPERIMENTS_ARE_FINAL
 
 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.
@@ -42,11 +69,12 @@ void PrintExperimentsList();
 // If this is called twice for the same experiment, both calls must agree.
 void ForceEnableExperiment(absl::string_view experiment_name, bool enable);
 
-struct ExperimentMetadata {
-  const char* name;
-  const char* description;
-  bool default_value;
-};
+// 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