grpc 1.54.3 → 1.59.2

data/src/core/lib/gprpp/type_list.h

@@ -0,0 +1,32 @@
+// 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.
+// 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_GPRPP_TYPE_LIST_H
+#define GRPC_SRC_CORE_LIB_GPRPP_TYPE_LIST_H
+
+namespace grpc_core {
+
+// A list of types
+template <typename... A>
+struct Typelist {
+  template <template <typename...> class T>
+  using Instantiate = T<A...>;
+
+  template <typename C>
+  using PushFront = Typelist<C, A...>;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_GPRPP_TYPE_LIST_H

data/src/core/lib/gprpp/validation_errors.cc

@@ -42,8 +42,14 @@ bool ValidationErrors::FieldHasErrors() const {
   return field_errors_.find(absl::StrJoin(fields_, "")) != field_errors_.end();
 }
 
-absl::Status ValidationErrors::status(absl::string_view prefix) const {
+absl::Status ValidationErrors::status(absl::StatusCode code,
+                                      absl::string_view prefix) const {
   if (field_errors_.empty()) return absl::OkStatus();
+  return absl::Status(code, message(prefix));
+}
+
+std::string ValidationErrors::message(absl::string_view prefix) const {
+  if (field_errors_.empty()) return "";
   std::vector<std::string> errors;
   for (const auto& p : field_errors_) {
     if (p.second.size() > 1) {
@@ -54,8 +60,7 @@ absl::Status ValidationErrors::status(absl::string_view prefix) const {
           absl::StrCat("field:", p.first, " error:", p.second[0]));
     }
   }
-  return absl::InvalidArgumentError(
-      absl::StrCat(prefix, ": [", absl::StrJoin(errors, "; "), "]"));
+  return absl::StrCat(prefix, ": [", absl::StrJoin(errors, "; "), "]");
 }
 
 }  // namespace grpc_core

data/src/core/lib/gprpp/validation_errors.h

@@ -40,25 +40,26 @@ namespace grpc_core {
 //   ValidationErrors errors;
 //   {
 //     ValidationErrors::ScopedField field("foo");
-//     auto it = json.object_value().find("foo");
-//     if (it == json.object_value().end()) {
+//     auto it = json.object().find("foo");
+//     if (it == json.object().end()) {
 //       errors.AddError("field not present");
-//     } else if (it->second.type() != Json::Type::OBJECT) {
+//     } else if (it->second.type() != Json::Type::kObject) {
 //       errors.AddError("must be a JSON object");
 //     } else {
 //       const Json& foo = it->second;
 //       ValidationErrors::ScopedField field(".bar");
-//       auto it = foo.object_value().find("bar");
-//       if (it == json.object_value().end()) {
+//       auto it = foo.object().find("bar");
+//       if (it == json.object().end()) {
 //         errors.AddError("field not present");
-//       } else if (it->second.type() != Json::Type::STRING) {
+//       } else if (it->second.type() != Json::Type::kString) {
 //         errors.AddError("must be a JSON string");
 //       } else {
-//         return it->second.string_value();
+//         return it->second.string();
 //       }
 //     }
 //   }
-//   return errors.status("errors validating foo.bar");
+//   return errors.status(absl::StatusCode::kInvalidArgument,
+//                        "errors validating foo.bar");
 // }
 class ValidationErrors {
  public:
@@ -100,7 +101,13 @@ class ValidationErrors {
   bool FieldHasErrors() const GPR_ATTRIBUTE_NOINLINE;
 
   // Returns the resulting status of parsing.
-  absl::Status status(absl::string_view prefix) const;
+  // If there are no errors, this will return an Ok status instead of using the
+  // prefix argument.
+  absl::Status status(absl::StatusCode code, absl::string_view prefix) const;
+
+  // Returns the resulting error message
+  // If there are no errors, this will return an empty string.
+  std::string message(absl::string_view prefix) const;
 
   // Returns true if there are no errors.
   bool ok() const { return field_errors_.empty(); }

data/src/core/lib/gprpp/work_serializer.cc

@@ -20,17 +20,28 @@
 
 #include <stdint.h>
 
+#include <algorithm>
 #include <atomic>
+#include <chrono>
 #include <functional>
 #include <memory>
+#include <thread>
 #include <utility>
 
+#include "absl/container/inlined_vector.h"
+
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/debug/stats.h"
+#include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {
 
@@ -42,11 +53,36 @@ DebugOnlyTraceFlag grpc_work_serializer_trace(false, "work_serializer");
 
 class WorkSerializer::WorkSerializerImpl : public Orphanable {
  public:
-  void Run(std::function<void()> callback, const DebugLocation& location);
-  void Schedule(std::function<void()> callback, const DebugLocation& location);
-  void DrainQueue();
+  virtual void Run(std::function<void()> callback,
+                   const DebugLocation& location) = 0;
+  virtual void Schedule(std::function<void()> callback,
+                        const DebugLocation& location) = 0;
+  virtual void DrainQueue() = 0;
+
+#ifndef NDEBUG
+  virtual bool RunningInWorkSerializer() const = 0;
+#endif
+};
+
+//
+// WorkSerializer::LegacyWorkSerializer
+//
+
+class WorkSerializer::LegacyWorkSerializer final : public WorkSerializerImpl {
+ public:
+  void Run(std::function<void()> callback,
+           const DebugLocation& location) override;
+  void Schedule(std::function<void()> callback,
+                const DebugLocation& location) override;
+  void DrainQueue() override;
   void Orphan() override;
 
+#ifndef NDEBUG
+  bool RunningInWorkSerializer() const override {
+    return std::this_thread::get_id() == current_thread_;
+  }
+#endif
+
  private:
   struct CallbackWrapper {
     CallbackWrapper(std::function<void()> cb, const DebugLocation& loc)
@@ -82,14 +118,25 @@ class WorkSerializer::WorkSerializerImpl : public Orphanable {
     return static_cast<uint64_t>(ref_pair & 0xffffffffffffu);
   }
 
+#ifndef NDEBUG
+  void SetCurrentThread() { current_thread_ = std::this_thread::get_id(); }
+  void ClearCurrentThread() { current_thread_ = std::thread::id(); }
+#else
+  void SetCurrentThread() {}
+  void ClearCurrentThread() {}
+#endif
+
   // An initial size of 1 keeps track of whether the work serializer has been
   // orphaned.
   std::atomic<uint64_t> refs_{MakeRefPair(0, 1)};
   MultiProducerSingleConsumerQueue queue_;
+#ifndef NDEBUG
+  std::thread::id current_thread_;
+#endif
 };
 
-void WorkSerializer::WorkSerializerImpl::Run(std::function<void()> callback,
-                                             const DebugLocation& location) {
+void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
+                                               const DebugLocation& location) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
     gpr_log(GPR_INFO, "WorkSerializer::Run() %p Scheduling callback [%s:%d]",
             this, location.file(), location.line());
@@ -102,10 +149,15 @@ void WorkSerializer::WorkSerializerImpl::Run(std::function<void()> callback,
   GPR_DEBUG_ASSERT(GetSize(prev_ref_pair) > 0);
   if (GetOwners(prev_ref_pair) == 0) {
     // We took ownership of the WorkSerializer. Invoke callback and drain queue.
+    SetCurrentThread();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
       gpr_log(GPR_INFO, "  Executing immediately");
     }
     callback();
+    // Delete the callback while still holding the WorkSerializer, so
+    // that any refs being held by the callback via lambda captures will
+    // be destroyed inside the WorkSerializer.
+    callback = nullptr;
     DrainQueueOwned();
   } else {
     // Another thread is holding the WorkSerializer, so decrement the ownership
@@ -120,7 +172,7 @@ void WorkSerializer::WorkSerializerImpl::Run(std::function<void()> callback,
   }
 }
 
-void WorkSerializer::WorkSerializerImpl::Schedule(
+void WorkSerializer::LegacyWorkSerializer::Schedule(
     std::function<void()> callback, const DebugLocation& location) {
   CallbackWrapper* cb_wrapper =
       new CallbackWrapper(std::move(callback), location);
@@ -133,7 +185,7 @@ void WorkSerializer::WorkSerializerImpl::Schedule(
   queue_.Push(&cb_wrapper->mpscq_node);
 }
 
-void WorkSerializer::WorkSerializerImpl::Orphan() {
+void WorkSerializer::LegacyWorkSerializer::Orphan() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
     gpr_log(GPR_INFO, "WorkSerializer::Orphan() %p", this);
   }
@@ -149,7 +201,7 @@ void WorkSerializer::WorkSerializerImpl::Orphan() {
 
 // The thread that calls this loans itself to the work serializer so as to
 // execute all the scheduled callbacks.
-void WorkSerializer::WorkSerializerImpl::DrainQueue() {
+void WorkSerializer::LegacyWorkSerializer::DrainQueue() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
     gpr_log(GPR_INFO, "WorkSerializer::DrainQueue() %p", this);
   }
@@ -158,6 +210,7 @@ void WorkSerializer::WorkSerializerImpl::DrainQueue() {
   const uint64_t prev_ref_pair =
       refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
   if (GetOwners(prev_ref_pair) == 0) {
+    SetCurrentThread();
     // We took ownership of the WorkSerializer. Drain the queue.
     DrainQueueOwned();
   } else {
@@ -169,7 +222,7 @@ void WorkSerializer::WorkSerializerImpl::DrainQueue() {
   }
 }
 
-void WorkSerializer::WorkSerializerImpl::DrainQueueOwned() {
+void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
     gpr_log(GPR_INFO, "WorkSerializer::DrainQueueOwned() %p", this);
   }
@@ -186,6 +239,10 @@ void WorkSerializer::WorkSerializerImpl::DrainQueueOwned() {
     }
     if (GetSize(prev_ref_pair) == 2) {
       // Queue drained. Give up ownership but only if queue remains empty.
+      // Reset current_thread_ before giving up ownership to avoid TSAN
+      // race.  If we don't wind up giving up ownership, we'll set this
+      // again below before we pull the next callback out of the queue.
+      ClearCurrentThread();
       uint64_t expected = MakeRefPair(1, 1);
       if (refs_.compare_exchange_strong(expected, MakeRefPair(0, 1),
                                         std::memory_order_acq_rel)) {
@@ -200,6 +257,8 @@ void WorkSerializer::WorkSerializerImpl::DrainQueueOwned() {
         delete this;
         return;
       }
+      // Didn't wind up giving up ownership, so set current_thread_ again.
+      SetCurrentThread();
     }
     // There is at least one callback on the queue. Pop the callback from the
     // queue and execute it.
@@ -223,14 +282,257 @@ void WorkSerializer::WorkSerializerImpl::DrainQueueOwned() {
   }
 }
 
+//
+// WorkSerializer::DispatchingWorkSerializer
+//
+
+// DispatchingWorkSerializer: executes callbacks one at a time on EventEngine.
+// One at a time guarantees that fixed size thread pools in EventEngine
+// implementations are not starved of threads by long running work serializers.
+// We implement EventEngine::Closure directly to avoid allocating once per
+// callback in the queue when scheduling.
+class WorkSerializer::DispatchingWorkSerializer final
+    : public WorkSerializerImpl,
+      public grpc_event_engine::experimental::EventEngine::Closure {
+ public:
+  explicit DispatchingWorkSerializer(
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+          event_engine)
+      : event_engine_(std::move(event_engine)) {}
+  void Run(std::function<void()> callback,
+           const DebugLocation& location) override;
+  void Schedule(std::function<void()> callback,
+                const DebugLocation& location) override {
+    // We always dispatch to event engine, so Schedule and Run share semantics.
+    Run(callback, location);
+  }
+  void DrainQueue() override {}
+  void Orphan() override;
+
+  // Override EventEngine::Closure
+  void Run() override;
+
+#ifndef NDEBUG
+  bool RunningInWorkSerializer() const override {
+    return running_work_serializer_ == this;
+  }
+#endif
+
+ private:
+  // Wrapper to capture DebugLocation for the callback.
+  struct CallbackWrapper {
+    CallbackWrapper(std::function<void()> cb, const DebugLocation& loc)
+        : callback(std::move(cb)), location(loc) {}
+    std::function<void()> callback;
+    // GPR_NO_UNIQUE_ADDRESS means this is 0 sized in release builds.
+    GPR_NO_UNIQUE_ADDRESS DebugLocation location;
+  };
+  using CallbackVector = absl::InlinedVector<CallbackWrapper, 1>;
+
+  // Refill processing_ from incoming_
+  // If processing_ is empty, also update running_ and return false.
+  // If additionally orphaned, will also delete this (therefore, it's not safe
+  // to touch any member variables if Refill returns false).
+  bool Refill();
+
+  // Perform the parts of Refill that need to acquire mu_
+  // Returns a tri-state indicating whether we were refilled successfully (=>
+  // keep running), or finished, and then if we were orphaned.
+  enum class RefillResult { kRefilled, kFinished, kFinishedAndOrphaned };
+  RefillResult RefillInner();
+
+#ifndef NDEBUG
+  void SetCurrentThread() { running_work_serializer_ = this; }
+  void ClearCurrentThread() { running_work_serializer_ = nullptr; }
+#else
+  void SetCurrentThread() {}
+  void ClearCurrentThread() {}
+#endif
+
+  // Member variables are roughly sorted to keep processing cache lines
+  // separated from incoming cache lines.
+
+  // Callbacks that are currently being processed.
+  // Only accessed by: a Run() call going from not-running to running, or a work
+  // item being executed in EventEngine -- ie this does not need a mutex because
+  // all access is serialized.
+  // Stored in reverse execution order so that callbacks can be `pop_back()`'d
+  // on completion to free up any resources they hold.
+  CallbackVector processing_;
+  // EventEngine instance upon which we'll do our work.
+  const std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+      event_engine_;
+  std::chrono::steady_clock::time_point running_start_time_
+      ABSL_GUARDED_BY(mu_);
+  std::chrono::steady_clock::duration time_running_items_;
+  uint64_t items_processed_during_run_;
+  // Flags containing run state:
+  // - running_ goes from false->true whenever the first callback is scheduled
+  //   on an idle WorkSerializer, and transitions back to false after the last
+  //   callback scheduled is completed and the WorkSerializer is again idle.
+  // - orphaned_ transitions to true once upon Orphan being called.
+  // When orphaned_ is true and running_ is false, the DispatchingWorkSerializer
+  // instance is deleted.
+  bool running_ ABSL_GUARDED_BY(mu_) = false;
+  bool orphaned_ ABSL_GUARDED_BY(mu_) = false;
+  Mutex mu_;
+  // Queued callbacks. New work items land here, and when processing_ is drained
+  // we move this entire queue into processing_ and work on draining it again.
+  // In low traffic scenarios this gives two mutex acquisitions per work item,
+  // but as load increases we get some natural batching and the rate of mutex
+  // acquisitions per work item tends towards 1.
+  CallbackVector incoming_ ABSL_GUARDED_BY(mu_);
+
+#ifndef NDEBUG
+  static thread_local DispatchingWorkSerializer* running_work_serializer_;
+#endif
+};
+
+#ifndef NDEBUG
+thread_local WorkSerializer::DispatchingWorkSerializer*
+    WorkSerializer::DispatchingWorkSerializer::running_work_serializer_ =
+        nullptr;
+#endif
+
+void WorkSerializer::DispatchingWorkSerializer::Orphan() {
+  ReleasableMutexLock lock(&mu_);
+  // If we're not running, then we can delete immediately.
+  if (!running_) {
+    lock.Release();
+    delete this;
+    return;
+  }
+  // Otherwise store a flag to delete when we're done.
+  orphaned_ = true;
+}
+
+// Implementation of WorkSerializerImpl::Run
+void WorkSerializer::DispatchingWorkSerializer::Run(
+    std::function<void()> callback, const DebugLocation& location) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+    gpr_log(GPR_INFO, "WorkSerializer[%p] Scheduling callback [%s:%d]", this,
+            location.file(), location.line());
+  }
+  global_stats().IncrementWorkSerializerItemsEnqueued();
+  MutexLock lock(&mu_);
+  if (!running_) {
+    // If we were previously idle, insert this callback directly into the empty
+    // processing_ list and start running.
+    running_ = true;
+    running_start_time_ = std::chrono::steady_clock::now();
+    items_processed_during_run_ = 0;
+    time_running_items_ = std::chrono::steady_clock::duration();
+    GPR_ASSERT(processing_.empty());
+    processing_.emplace_back(std::move(callback), location);
+    event_engine_->Run(this);
+  } else {
+    // We are already running, so add this callback to the incoming_ list.
+    // The work loop will eventually get to it.
+    incoming_.emplace_back(std::move(callback), location);
+  }
+}
+
+// Implementation of EventEngine::Closure::Run - our actual work loop
+void WorkSerializer::DispatchingWorkSerializer::Run() {
+  // TODO(ctiller): remove these when we can deprecate ExecCtx
+  ApplicationCallbackExecCtx app_exec_ctx;
+  ExecCtx exec_ctx;
+  // Grab the last element of processing_ - which is the next item in our queue
+  // since processing_ is stored in reverse order.
+  auto& cb = processing_.back();
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+    gpr_log(GPR_INFO, "WorkSerializer[%p] Executing callback [%s:%d]", this,
+            cb.location.file(), cb.location.line());
+  }
+  // Run the work item.
+  const auto start = std::chrono::steady_clock::now();
+  SetCurrentThread();
+  cb.callback();
+  // pop_back here destroys the callback - freeing any resources it might hold.
+  // We do so before clearing the current thread in case the callback destructor
+  // wants to check that it's in the WorkSerializer too.
+  processing_.pop_back();
+  ClearCurrentThread();
+  global_stats().IncrementWorkSerializerItemsDequeued();
+  const auto work_time = std::chrono::steady_clock::now() - start;
+  global_stats().IncrementWorkSerializerWorkTimePerItemMs(
+      std::chrono::duration_cast<std::chrono::milliseconds>(work_time).count());
+  time_running_items_ += work_time;
+  ++items_processed_during_run_;
+  // Check if we've drained the queue and if so refill it.
+  if (processing_.empty() && !Refill()) return;
+  // There's still work in processing_, so schedule ourselves again on
+  // EventEngine.
+  event_engine_->Run(this);
+}
+
+WorkSerializer::DispatchingWorkSerializer::RefillResult
+WorkSerializer::DispatchingWorkSerializer::RefillInner() {
+  // Recover any memory held by processing_, so that we don't grow forever.
+  // Do so before acquiring a lock so we don't cause inadvertent contention.
+  processing_.shrink_to_fit();
+  MutexLock lock(&mu_);
+  // Swap incoming_ into processing_ - effectively lets us release memory
+  // (outside the lock) once per iteration for the storage vectors.
+  processing_.swap(incoming_);
+  // If there were no items, then we've finished running.
+  if (processing_.empty()) {
+    running_ = false;
+    global_stats().IncrementWorkSerializerRunTimeMs(
+        std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now() - running_start_time_)
+            .count());
+    global_stats().IncrementWorkSerializerWorkTimeMs(
+        std::chrono::duration_cast<std::chrono::milliseconds>(
+            time_running_items_)
+            .count());
+    global_stats().IncrementWorkSerializerItemsPerRun(
+        items_processed_during_run_);
+    // And if we're also orphaned then it's time to delete this object.
+    if (orphaned_) {
+      return RefillResult::kFinishedAndOrphaned;
+    } else {
+      return RefillResult::kFinished;
+    }
+  }
+  return RefillResult::kRefilled;
+}
+
+bool WorkSerializer::DispatchingWorkSerializer::Refill() {
+  const auto result = RefillInner();
+  switch (result) {
+    case RefillResult::kRefilled:
+      // Reverse processing_ so that we can pop_back() items in the correct
+      // order. (note that this is mostly pointer swaps inside the
+      // std::function's, so should be relatively cheap even for longer lists).
+      // Do so here so we're outside of the RefillInner lock.
+      std::reverse(processing_.begin(), processing_.end());
+      return true;
+    case RefillResult::kFinished:
+      return false;
+    case RefillResult::kFinishedAndOrphaned:
+      // Orphaned and finished - finally delete this object.
+      // Here so that the mutex lock in RefillInner is released.
+      delete this;
+      return false;
+  }
+  GPR_UNREACHABLE_CODE(return false);
+}
+
 //
 // WorkSerializer
 //
 
-WorkSerializer::WorkSerializer()
-    : impl_(MakeOrphanable<WorkSerializerImpl>()) {}
+WorkSerializer::WorkSerializer(
+    std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine)
+    : impl_(IsWorkSerializerDispatchEnabled()
+                ? OrphanablePtr<WorkSerializerImpl>(
+                      MakeOrphanable<DispatchingWorkSerializer>(
+                          std::move(event_engine)))
+                : OrphanablePtr<WorkSerializerImpl>(
+                      MakeOrphanable<LegacyWorkSerializer>())) {}
 
-WorkSerializer::~WorkSerializer() {}
+WorkSerializer::~WorkSerializer() = default;
 
 void WorkSerializer::Run(std::function<void()> callback,
                          const DebugLocation& location) {
@@ -244,4 +546,10 @@ void WorkSerializer::Schedule(std::function<void()> callback,
 
 void WorkSerializer::DrainQueue() { impl_->DrainQueue(); }
 
+#ifndef NDEBUG
+bool WorkSerializer::RunningInWorkSerializer() const {
+  return impl_->RunningInWorkSerializer();
+}
+#endif
+
 }  // namespace grpc_core

data/src/core/lib/gprpp/work_serializer.h

@@ -20,9 +20,12 @@
 #include <grpc/support/port_platform.h>
 
 #include <functional>
+#include <memory>
 
 #include "absl/base/thread_annotations.h"
 
+#include <grpc/event_engine/event_engine.h>
+
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 
@@ -44,14 +47,28 @@ namespace grpc_core {
 // invoke DrainQueue() when it is safe to invoke the callback.
 class ABSL_LOCKABLE WorkSerializer {
  public:
-  WorkSerializer();
-
+  explicit WorkSerializer(
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+          event_engine);
   ~WorkSerializer();
 
-  // Runs a given callback on the work serializer. If there is no other thread
-  // currently executing the WorkSerializer, the callback is run immediately. In
-  // this case, the current thread is also borrowed for draining the queue for
-  // any callbacks that get added in the meantime.
+  WorkSerializer(const WorkSerializer&) = delete;
+  WorkSerializer& operator=(const WorkSerializer&) = delete;
+  WorkSerializer(WorkSerializer&&) noexcept = default;
+  WorkSerializer& operator=(WorkSerializer&&) noexcept = default;
+
+  // Runs a given callback on the work serializer.
+  //
+  // If experiment `work_serializer_dispatch` is enabled:
+  // The callback will be executed as an EventEngine callback, that then
+  // arranges for the next callback in the queue to execute.
+  //
+  // If experiment `work_serializer_dispatch` is NOT enabled:
+  // If there is no other thread currently executing the WorkSerializer, the
+  // callback is run immediately. In this case, the current thread is also
+  // borrowed for draining the queue for any callbacks that get added in the
+  // meantime.
+  // This behavior is deprecated and will be removed soon.
   //
   // If you want to use clang thread annotation to make sure that callback is
   // called by WorkSerializer only, you need to add the annotation to both the
@@ -64,9 +81,6 @@ class ABSL_LOCKABLE WorkSerializer {
   //         }, DEBUG_LOCATION);
   //   }
   //   void callback() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) { ... }
-  //
-  // TODO(yashkt): Replace DebugLocation with absl::SourceLocation
-  // once we can start using it directly.
   void Run(std::function<void()> callback, const DebugLocation& location);
 
   // Schedule \a callback to be run later when the queue of callbacks is
@@ -75,8 +89,15 @@ class ABSL_LOCKABLE WorkSerializer {
   // Drains the queue of callbacks.
   void DrainQueue();
 
+#ifndef NDEBUG
+  // Returns true if the current thread is running in the WorkSerializer.
+  bool RunningInWorkSerializer() const;
+#endif
+
  private:
   class WorkSerializerImpl;
+  class LegacyWorkSerializer;
+  class DispatchingWorkSerializer;
 
   OrphanablePtr<WorkSerializerImpl> impl_;
 };

data/src/core/lib/http/httpcli.h

@@ -100,12 +100,11 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   //   nullptr is treated as insecure credentials.
   //   TODO(yihuaz): disallow nullptr as a value after unsecure builds
   //   are removed.
-  static OrphanablePtr<HttpRequest> Get(
+  GRPC_MUST_USE_RESULT static OrphanablePtr<HttpRequest> Get(
       URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
       const grpc_http_request* request, Timestamp deadline,
       grpc_closure* on_done, grpc_http_response* response,
-      RefCountedPtr<grpc_channel_credentials> channel_creds)
-      GRPC_MUST_USE_RESULT;
+      RefCountedPtr<grpc_channel_credentials> channel_creds);
 
   // Asynchronously perform a HTTP POST.
   // 'uri' is the target to make the request to. The scheme field is used to
@@ -126,12 +125,11 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   //   TODO(apolcyn): disallow nullptr as a value after unsecure builds
   //   are removed.
   // Does not support ?var1=val1&var2=val2 in the path.
-  static OrphanablePtr<HttpRequest> Post(
+  GRPC_MUST_USE_RESULT static OrphanablePtr<HttpRequest> Post(
       URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
       const grpc_http_request* request, Timestamp deadline,
       grpc_closure* on_done, grpc_http_response* response,
-      RefCountedPtr<grpc_channel_credentials> channel_creds)
-      GRPC_MUST_USE_RESULT;
+      RefCountedPtr<grpc_channel_credentials> channel_creds);
 
   // Asynchronously perform a HTTP PUT.
   // 'uri' is the target to make the request to. The scheme field is used to
@@ -152,12 +150,11 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   //   TODO(apolcyn): disallow nullptr as a value after unsecure builds
   //   are removed.
   // Does not support ?var1=val1&var2=val2 in the path.
-  static OrphanablePtr<HttpRequest> Put(
+  GRPC_MUST_USE_RESULT static OrphanablePtr<HttpRequest> Put(
       URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
       const grpc_http_request* request, Timestamp deadline,
       grpc_closure* on_done, grpc_http_response* response,
-      RefCountedPtr<grpc_channel_credentials> channel_creds)
-      GRPC_MUST_USE_RESULT;
+      RefCountedPtr<grpc_channel_credentials> channel_creds);
 
   HttpRequest(URI uri, const grpc_slice& request_text,
               grpc_http_response* response, Timestamp deadline,

data/src/core/lib/http/httpcli_security_connector.cc

@@ -29,6 +29,7 @@
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>