grpc 1.52.0 → 1.53.0.pre2

data/src/core/lib/promise/if.h

@@ -0,0 +1,195 @@
+// Copyright 2021 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_PROMISE_IF_H
+#define GRPC_SRC_CORE_LIB_PROMISE_IF_H
+
+#include <grpc/support/port_platform.h>
+
+#include <type_traits>
+
+#include "absl/status/statusor.h"
+#include "absl/types/variant.h"
+
+#include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/promise/detail/promise_factory.h"
+#include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+template <typename CallPoll, typename T, typename F>
+typename CallPoll::PollResult ChooseIf(CallPoll call_poll, bool result,
+                                       T* if_true, F* if_false) {
+  if (result) {
+    auto promise = if_true->Make();
+    return call_poll(promise);
+  } else {
+    auto promise = if_false->Make();
+    return call_poll(promise);
+  }
+}
+
+template <typename CallPoll, typename T, typename F>
+typename CallPoll::PollResult ChooseIf(CallPoll call_poll,
+                                       absl::StatusOr<bool> result, T* if_true,
+                                       F* if_false) {
+  if (!result.ok()) {
+    return typename CallPoll::PollResult(result.status());
+  } else if (*result) {
+    auto promise = if_true->Make();
+    return call_poll(promise);
+  } else {
+    auto promise = if_false->Make();
+    return call_poll(promise);
+  }
+}
+
+template <typename C, typename T, typename F>
+class If {
+ private:
+  using TrueFactory = promise_detail::OncePromiseFactory<void, T>;
+  using FalseFactory = promise_detail::OncePromiseFactory<void, F>;
+  using ConditionPromise = PromiseLike<C>;
+  using TruePromise = typename TrueFactory::Promise;
+  using FalsePromise = typename FalseFactory::Promise;
+  using Result =
+      typename PollTraits<decltype(std::declval<TruePromise>()())>::Type;
+
+ public:
+  If(C condition, T if_true, F if_false)
+      : state_(Evaluating{ConditionPromise(std::move(condition)),
+                          TrueFactory(std::move(if_true)),
+                          FalseFactory(std::move(if_false))}) {}
+
+  Poll<Result> operator()() {
+    return absl::visit(CallPoll<false>{this}, state_);
+  }
+
+ private:
+  struct Evaluating {
+    ConditionPromise condition;
+    TrueFactory if_true;
+    FalseFactory if_false;
+  };
+  using State = absl::variant<Evaluating, TruePromise, FalsePromise>;
+  State state_;
+
+  template <bool kSetState>
+  struct CallPoll {
+    using PollResult = Poll<Result>;
+
+    If* const self;
+
+    PollResult operator()(Evaluating& evaluating) const {
+      static_assert(
+          !kSetState,
+          "shouldn't need to set state coming through the initial branch");
+      auto r = evaluating.condition();
+      if (auto* p = r.value_if_ready()) {
+        return ChooseIf(CallPoll<true>{self}, std::move(*p),
+                        &evaluating.if_true, &evaluating.if_false);
+      }
+      return Pending();
+    }
+
+    template <class Promise>
+    PollResult operator()(Promise& promise) const {
+      auto r = promise();
+      if (kSetState && r.pending()) {
+        self->state_.template emplace<Promise>(std::move(promise));
+      }
+      return r;
+    }
+  };
+};
+
+template <typename T, typename F>
+class If<bool, T, F> {
+ private:
+  using TrueFactory = promise_detail::OncePromiseFactory<void, T>;
+  using FalseFactory = promise_detail::OncePromiseFactory<void, F>;
+  using TruePromise = typename TrueFactory::Promise;
+  using FalsePromise = typename FalseFactory::Promise;
+  using Result =
+      typename PollTraits<decltype(std::declval<TruePromise>()())>::Type;
+
+ public:
+  If(bool condition, T if_true, F if_false) : condition_(condition) {
+    TrueFactory true_factory(std::move(if_true));
+    FalseFactory false_factory(std::move(if_false));
+    if (condition_) {
+      Construct(&if_true_, true_factory.Make());
+    } else {
+      Construct(&if_false_, false_factory.Make());
+    }
+  }
+  ~If() {
+    if (condition_) {
+      Destruct(&if_true_);
+    } else {
+      Destruct(&if_false_);
+    }
+  }
+
+  If(const If&) = delete;
+  If& operator=(const If&) = delete;
+  If(If&& other) noexcept : condition_(other.condition_) {
+    if (condition_) {
+      Construct(&if_true_, std::move(other.if_true_));
+    } else {
+      Construct(&if_false_, std::move(other.if_false_));
+    }
+  }
+  If& operator=(If&& other) noexcept {
+    if (&other == this) return *this;
+    Destruct(this);
+    Construct(this, std::move(other));
+    return *this;
+  }
+
+  Poll<Result> operator()() {
+    if (condition_) {
+      return if_true_();
+    } else {
+      return if_false_();
+    }
+  }
+
+ private:
+  bool condition_;
+  union {
+    TruePromise if_true_;
+    FalsePromise if_false_;
+  };
+};
+
+}  // namespace promise_detail
+
+// If promise combinator.
+// Takes 3 promise factories, and evaluates the first.
+// If it returns failure, returns failure for the entire combinator.
+// If it returns true, evaluates the second promise.
+// If it returns false, evaluates the third promise.
+template <typename C, typename T, typename F>
+promise_detail::If<C, T, F> If(C condition, T if_true, F if_false) {
+  return promise_detail::If<C, T, F>(std::move(condition), std::move(if_true),
+                                     std::move(if_false));
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_IF_H

data/src/core/lib/promise/interceptor_list.h

@@ -0,0 +1,308 @@
+// Copyright 2022 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_PROMISE_INTERCEPTOR_LIST_H
+#define GRPC_SRC_CORE_LIB_PROMISE_INTERCEPTOR_LIST_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <new>
+#include <string>
+#include <utility>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/types/optional.h"
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/detail/promise_factory.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/trace.h"
+#include "src/core/lib/resource_quota/arena.h"
+
+namespace grpc_core {
+
+// Tracks a list of maps of T -> optional<T> via promises.
+// When Run, runs each transformation in order, and resolves to the ulimate
+// result.
+// If a map resolves to nullopt, the chain is terminated and the result is
+// nullopt.
+// Maps can also have synchronous cleanup functions, which are guaranteed to be
+// called at the termination of each run through the chain.
+template <typename T>
+class InterceptorList {
+ private:
+  // A map of T -> T via promises.
+  class Map {
+   public:
+    explicit Map(DebugLocation from) : from_(from) {}
+    // Construct a promise to transform x into some other value at memory.
+    virtual void MakePromise(T x, void* memory) = 0;
+    // Destroy a promise constructed at memory.
+    virtual void Destroy(void* memory) = 0;
+    // Poll a promise constructed at memory.
+    // Resolves to an optional<T> -- if nullopt it means terminate the chain and
+    // resolve.
+    virtual Poll<absl::optional<T>> PollOnce(void* memory) = 0;
+    virtual ~Map() = default;
+
+    // Update the next pointer stored with this map.
+    // This is only valid to call once, and only before the map is used.
+    void SetNext(Map* next) {
+      GPR_DEBUG_ASSERT(next_ == nullptr);
+      next_ = next;
+    }
+
+    // Access the creation location for this map (for debug tracing).
+    DebugLocation from() const { return from_; }
+
+    // Access the next map in the chain (or nullptr if this is the last map).
+    Map* next() const { return next_; }
+
+   private:
+    GPR_NO_UNIQUE_ADDRESS const DebugLocation from_;
+    Map* next_ = nullptr;
+  };
+
+ public:
+  // The result of Run: a promise that will execute the entire chain.
+  class RunPromise {
+   public:
+    RunPromise(size_t memory_required, Map* factory, absl::optional<T> value) {
+      if (!value.has_value() || factory == nullptr) {
+        is_immediately_resolved_ = true;
+        Construct(&result_, std::move(value));
+      } else {
+        is_immediately_resolved_ = false;
+        Construct(&async_resolution_, memory_required);
+        factory->MakePromise(std::move(*value), async_resolution_.space.get());
+        async_resolution_.current_factory = factory;
+      }
+    }
+
+    ~RunPromise() {
+      if (is_immediately_resolved_) {
+        Destruct(&result_);
+      } else {
+        if (async_resolution_.current_factory != nullptr) {
+          async_resolution_.current_factory->Destroy(
+              async_resolution_.space.get());
+        }
+        Destruct(&async_resolution_);
+      }
+    }
+
+    RunPromise(const RunPromise&) = delete;
+    RunPromise& operator=(const RunPromise&) = delete;
+
+    RunPromise(RunPromise&& other) noexcept
+        : is_immediately_resolved_(other.is_immediately_resolved_) {
+      if (is_immediately_resolved_) {
+        Construct(&result_, std::move(other.result_));
+      } else {
+        Construct(&async_resolution_, std::move(other.async_resolution_));
+      }
+    }
+
+    RunPromise& operator=(RunPromise&& other) noexcept = delete;
+
+    Poll<absl::optional<T>> operator()() {
+      if (grpc_trace_promise_primitives.enabled()) {
+        gpr_log(GPR_DEBUG, "InterceptorList::RunPromise: %s",
+                DebugString().c_str());
+      }
+      if (is_immediately_resolved_) return std::move(result_);
+      while (true) {
+        auto r = async_resolution_.current_factory->PollOnce(
+            async_resolution_.space.get());
+        if (auto* p = r.value_if_ready()) {
+          async_resolution_.current_factory->Destroy(
+              async_resolution_.space.get());
+          async_resolution_.current_factory =
+              async_resolution_.current_factory->next();
+          if (async_resolution_.current_factory == nullptr || !p->has_value()) {
+            return std::move(*p);
+          }
+          async_resolution_.current_factory->MakePromise(
+              std::move(**p), async_resolution_.space.get());
+          continue;
+        }
+        return Pending{};
+      }
+    }
+
+   private:
+    std::string DebugString() const {
+      if (is_immediately_resolved_) {
+        return absl::StrFormat("Result:has_value:%d", result_.has_value());
+      } else {
+        return absl::StrCat(
+            "Running:",
+            async_resolution_.current_factory == nullptr
+                ? "END"
+                : ([p = async_resolution_.current_factory->from()]() {
+                    return absl::StrCat(p.file(), ":", p.line());
+                  })()
+                      .c_str());
+      }
+    }
+    struct AsyncResolution {
+      explicit AsyncResolution(size_t max_size)
+          : space(GetContext<Arena>()->MakePooledArray<char>(max_size)) {}
+      AsyncResolution(const AsyncResolution&) = delete;
+      AsyncResolution& operator=(const AsyncResolution&) = delete;
+      AsyncResolution(AsyncResolution&& other) noexcept
+          : current_factory(std::exchange(other.current_factory, nullptr)),
+            space(std::move(other.space)) {}
+      Map* current_factory;
+      Arena::PoolPtr<char[]> space;
+    };
+    union {
+      AsyncResolution async_resolution_;
+      absl::optional<T> result_;
+    };
+    // If true, the result_ union is valid, otherwise async_resolution_ is.
+    // Indicates whether the promise resolved immediately at construction or if
+    // additional steps were needed.
+    bool is_immediately_resolved_;
+  };
+
+  InterceptorList() = default;
+  InterceptorList(const InterceptorList&) = delete;
+  InterceptorList& operator=(const InterceptorList&) = delete;
+  ~InterceptorList() { DeleteFactories(); }
+
+  RunPromise Run(absl::optional<T> initial_value) {
+    return RunPromise(promise_memory_required_, first_map_,
+                      std::move(initial_value));
+  }
+
+  // Append a new map to the end of the chain.
+  template <typename Fn>
+  void AppendMap(Fn fn, DebugLocation from) {
+    Append(MakeMapToAdd(
+        std::move(fn), [] {}, from));
+  }
+
+  // Prepend a new map to the beginning of the chain.
+  template <typename Fn>
+  void PrependMap(Fn fn, DebugLocation from) {
+    Prepend(MakeMapToAdd(
+        std::move(fn), [] {}, from));
+  }
+
+  // Append a new map to the end of the chain, with a cleanup function to be
+  // called at the end of run promise execution.
+  template <typename Fn, typename CleanupFn>
+  void AppendMapWithCleanup(Fn fn, CleanupFn cleanup_fn, DebugLocation from) {
+    Append(MakeMapToAdd(std::move(fn), std::move(cleanup_fn), from));
+  }
+
+  // Prepend a new map to the beginning of the chain, with a cleanup function to
+  // be called at the end of run promise execution.
+  template <typename Fn, typename CleanupFn>
+  void PrependMapWithCleanup(Fn fn, CleanupFn cleanup_fn, DebugLocation from) {
+    Prepend(MakeMapToAdd(std::move(fn), std::move(cleanup_fn), from));
+  }
+
+ protected:
+  // Clear the interceptor list
+  void ResetInterceptorList() {
+    DeleteFactories();
+    first_map_ = nullptr;
+    last_map_ = nullptr;
+    promise_memory_required_ = 0;
+  }
+
+ private:
+  template <typename Fn, typename CleanupFn>
+  class MapImpl final : public Map {
+   public:
+    using PromiseFactory = promise_detail::RepeatedPromiseFactory<T, Fn>;
+    using Promise = typename PromiseFactory::Promise;
+
+    explicit MapImpl(Fn fn, CleanupFn cleanup_fn, DebugLocation from)
+        : Map(from), fn_(std::move(fn)), cleanup_fn_(std::move(cleanup_fn)) {}
+    ~MapImpl() override { cleanup_fn_(); }
+    void MakePromise(T x, void* memory) override {
+      new (memory) Promise(fn_.Make(std::move(x)));
+    }
+    void Destroy(void* memory) override {
+      static_cast<Promise*>(memory)->~Promise();
+    }
+    Poll<absl::optional<T>> PollOnce(void* memory) override {
+      return poll_cast<absl::optional<T>>((*static_cast<Promise*>(memory))());
+    }
+
+   private:
+    GPR_NO_UNIQUE_ADDRESS PromiseFactory fn_;
+    GPR_NO_UNIQUE_ADDRESS CleanupFn cleanup_fn_;
+  };
+
+  template <typename Fn, typename CleanupFn>
+  Map* MakeMapToAdd(Fn fn, CleanupFn cleanup_fn, DebugLocation from) {
+    using FactoryType = MapImpl<Fn, CleanupFn>;
+    promise_memory_required_ = std::max(promise_memory_required_,
+                                        sizeof(typename FactoryType::Promise));
+    return GetContext<Arena>()->New<FactoryType>(std::move(fn),
+                                                 std::move(cleanup_fn), from);
+  }
+
+  void Append(Map* f) {
+    if (first_map_ == nullptr) {
+      first_map_ = f;
+      last_map_ = f;
+    } else {
+      last_map_->SetNext(f);
+      last_map_ = f;
+    }
+  }
+
+  void Prepend(Map* f) {
+    if (first_map_ == nullptr) {
+      first_map_ = f;
+      last_map_ = f;
+    } else {
+      f->SetNext(first_map_);
+      first_map_ = f;
+    }
+  }
+
+  void DeleteFactories() {
+    for (auto* f = first_map_; f != nullptr;) {
+      auto* next = f->next();
+      f->~Map();
+      f = next;
+    }
+  }
+
+  // The first map in the chain.
+  Map* first_map_ = nullptr;
+  // The last map in the chain.
+  Map* last_map_ = nullptr;
+  // The amount of memory required to store the largest promise in the chain.
+  size_t promise_memory_required_ = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_INTERCEPTOR_LIST_H

data/src/core/lib/promise/intra_activity_waiter.h

@@ -12,11 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_INTRA_ACTIVITY_WAITER_H
-#define GRPC_CORE_LIB_PROMISE_INTRA_ACTIVITY_WAITER_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_INTRA_ACTIVITY_WAITER_H
+#define GRPC_SRC_CORE_LIB_PROMISE_INTRA_ACTIVITY_WAITER_H
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
 
@@ -40,10 +42,14 @@ class IntraActivityWaiter {
     }
   }
 
+  std::string DebugString() const {
+    return waiting_ ? "WAITING" : "NOT_WAITING";
+  }
+
  private:
   bool waiting_ = false;
 };
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_INTRA_ACTIVITY_WAITER_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_INTRA_ACTIVITY_WAITER_H

data/src/core/lib/promise/latch.h

@@ -12,17 +12,26 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_LATCH_H
-#define GRPC_CORE_LIB_PROMISE_LATCH_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_LATCH_H
+#define GRPC_SRC_CORE_LIB_PROMISE_LATCH_H
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
+#include <string>
 #include <type_traits>
+#include <utility>
+
+#include "absl/strings/str_cat.h"
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/intra_activity_waiter.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/trace.h"
 
 namespace grpc_core {
 
@@ -56,9 +65,13 @@ class Latch {
 #ifndef NDEBUG
     has_had_waiters_ = true;
 #endif
-    return [this]() -> Poll<T*> {
+    return [this]() -> Poll<T> {
+      if (grpc_trace_promise_primitives.enabled()) {
+        gpr_log(GPR_INFO, "%sPollWait %s", DebugTag().c_str(),
+                StateString().c_str());
+      }
       if (has_value_) {
-        return &value_;
+        return std::move(value_);
       } else {
         return waiter_.pending();
       }
@@ -67,6 +80,9 @@ class Latch {
 
   // Set the value of the latch. Can only be called once.
   void Set(T value) {
+    if (grpc_trace_promise_primitives.enabled()) {
+      gpr_log(GPR_INFO, "%sSet %s", DebugTag().c_str(), StateString().c_str());
+    }
     GPR_DEBUG_ASSERT(!has_value_);
     value_ = std::move(value);
     has_value_ = true;
@@ -74,6 +90,16 @@ class Latch {
   }
 
  private:
+  std::string DebugTag() {
+    return absl::StrCat(Activity::current()->DebugTag(), " LATCH[0x",
+                        reinterpret_cast<uintptr_t>(this), "]: ");
+  }
+
+  std::string StateString() {
+    return absl::StrCat("has_value:", has_value_ ? "true" : "false",
+                        " waiter:", waiter_.DebugString());
+  }
+
   // The value stored (if has_value_ is true), otherwise some random value, we
   // don't care.
   // Why not absl::optional<>? Writing things this way lets us compress
@@ -89,9 +115,77 @@ class Latch {
   IntraActivityWaiter waiter_;
 };
 
+// Specialization for void.
+template <>
+class Latch<void> {
+ public:
+  Latch() = default;
+  Latch(const Latch&) = delete;
+  Latch& operator=(const Latch&) = delete;
+  Latch(Latch&& other) noexcept : is_set_(other.is_set_) {
+#ifndef NDEBUG
+    GPR_DEBUG_ASSERT(!other.has_had_waiters_);
+#endif
+  }
+  Latch& operator=(Latch&& other) noexcept {
+#ifndef NDEBUG
+    GPR_DEBUG_ASSERT(!other.has_had_waiters_);
+#endif
+    is_set_ = other.is_set_;
+    return *this;
+  }
+
+  // Produce a promise to wait for this latch.
+  auto Wait() {
+#ifndef NDEBUG
+    has_had_waiters_ = true;
+#endif
+    return [this]() -> Poll<Empty> {
+      if (grpc_trace_promise_primitives.enabled()) {
+        gpr_log(GPR_INFO, "%sPollWait %s", DebugTag().c_str(),
+                StateString().c_str());
+      }
+      if (is_set_) {
+        return Empty{};
+      } else {
+        return waiter_.pending();
+      }
+    };
+  }
+
+  // Set the latch. Can only be called once.
+  void Set() {
+    if (grpc_trace_promise_primitives.enabled()) {
+      gpr_log(GPR_INFO, "%sSet %s", DebugTag().c_str(), StateString().c_str());
+    }
+    GPR_DEBUG_ASSERT(!is_set_);
+    is_set_ = true;
+    waiter_.Wake();
+  }
+
+ private:
+  std::string DebugTag() {
+    return absl::StrCat(Activity::current()->DebugTag(), " LATCH[0x",
+                        reinterpret_cast<uintptr_t>(this), "]: ");
+  }
+
+  std::string StateString() {
+    return absl::StrCat("is_set:", is_set_ ? "true" : "false",
+                        " waiter:", waiter_.DebugString());
+  }
+
+  // True if we have a value set, false otherwise.
+  bool is_set_ = false;
+#ifndef NDEBUG
+  // Has this latch ever had waiters.
+  bool has_had_waiters_ = false;
+#endif
+  IntraActivityWaiter waiter_;
+};
+
 template <typename T>
 using LatchWaitPromise = decltype(std::declval<Latch<T>>().Wait());
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_LATCH_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_LATCH_H