grpc 1.70.1 → 1.71.0

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

@@ -19,9 +19,9 @@
 
 #include <utility>
 
-namespace grpc_core {
+#include "src/core/lib/promise/detail/promise_like.h"
 
-namespace promise_detail {
+namespace grpc_core {
 
 template <typename A, typename B>
 class TwoPartyPrioritizedRace {
@@ -36,23 +36,25 @@ class TwoPartyPrioritizedRace {
     auto p = a_();
     if (p.ready()) return p;
     // Check the other promise.
-    p = b_();
-    if (p.ready()) {
-      // re-poll a to see if it's also completed.
-      auto q = a_();
-      if (q.ready()) {
-        // both are ready, but a is prioritized
-        return q;
-      }
+    auto q = b_();
+    if (!q.ready()) return q;
+    // re-poll a to see if it's also completed.
+    auto r = a_();
+    if (r.ready()) {
+      // both are ready, but a is prioritized
+      return r;
     }
-    return p;
+    return q;
   }
 
  private:
-  A a_;
-  B b_;
+  promise_detail::PromiseLike<A> a_;
+  promise_detail::PromiseLike<B> b_;
 };
 
+/// Run all the promises until one is non-pending.
+/// Once there's a non-pending promise, repoll all the promises before that.
+/// Return the result from the lexically first non-pending promise.
 template <typename... Promises>
 class PrioritizedRace;
 
@@ -78,16 +80,8 @@ class PrioritizedRace<Promise> {
   Promise promise_;
 };
 
-}  // namespace promise_detail
-
-/// Run all the promises until one is non-pending.
-/// Once there's a non-pending promise, repoll all the promises before that.
-/// Return the result from the lexically first non-pending promise.
 template <typename... Promises>
-promise_detail::PrioritizedRace<Promises...> PrioritizedRace(
-    Promises... promises) {
-  return promise_detail::PrioritizedRace<Promises...>(std::move(promises)...);
-}
+PrioritizedRace(Promises...) -> PrioritizedRace<Promises...>;
 
 }  // namespace grpc_core
 

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

@@ -17,12 +17,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <type_traits>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
 
@@ -38,7 +37,7 @@ using Promise = absl::AnyInvocable<Poll<T>()>;
 // nothing.
 template <typename Promise>
 auto NowOrNever(Promise promise)
-    -> absl::optional<typename promise_detail::PromiseLike<Promise>::Result> {
+    -> std::optional<typename promise_detail::PromiseLike<Promise>::Result> {
   auto r = promise_detail::PromiseLike<Promise>(std::move(promise))();
   if (auto* p = r.value_if_ready()) {
     return std::move(*p);

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

@@ -21,9 +21,9 @@
 
 namespace grpc_core {
 
-namespace promise_detail {
-
-// Implementation type for Race combinator.
+/// Run all the promises, return the first result that's available.
+/// If two results are simultaneously available, bias towards the first result
+/// listed.
 template <typename... Promises>
 class Race;
 
@@ -68,16 +68,8 @@ class Race<Promise> {
   Promise promise_;
 };
 
-}  // namespace promise_detail
-
-/// Run all the promises, return the first result that's available.
-/// If two results are simultaneously available, bias towards the first result
-/// listed.
 template <typename... Promises>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Race<Promises...>
-Race(Promises... promises) {
-  return promise_detail::Race<Promises...>(std::move(promises)...);
-}
+Race(Promises...) -> Race<Promises...>;
 
 }  // namespace grpc_core
 

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

@@ -28,6 +28,47 @@
 
 namespace grpc_core {
 
+// Seq Promise combinator.
+//
+// Seq stands for sequence.
+//
+// Input :
+// 1. The seq combinator needs minimum one promise as input.
+// 2. The first input to seq combinator is a promise.
+// 3. The remaining inputs to seq combinator are promise factories. The input
+// type of the Nth functor should be the return value of the (N-1)th promise.
+//
+// Return :
+// Polling the Seq Promise combinator returns Poll<T> where T is the type
+// returned by the last promise in the list of input promises.
+//
+// Polling the Seq combinator works in the following way :
+// Run the first promise. If it returns Pending{}, nothing else is executed.
+// If the first promise returns a value, pass this result to the second functor,
+// and run the returned promise. If it returns Pending{}, nothing else is
+// executed. If it returns a value, pass this result to the third, and run the
+// returned promise. etc. Return the final value.
+//
+// If any of the promises in the Seq chain returns a failure status, Seq will
+// still proceed with the execution of the remaining promises. If you want the
+// execution to stop when a failure status is received, use the TrySeq
+// combinator instead.
+//
+// Promises in the Seq combinator are run in order, serially and on the same
+// thread.
+//
+// Example :
+//
+// TEST(SeqTest, TwoThens) {
+//   auto initial = [] { return std::string("a"); };
+//   auto next1 = [](std::string i) { return [i]() { return i + "b"; }; };
+//   auto next2 = [](std::string i) { return [i]() { return i + "c"; }; };
+//   EXPECT_EQ(Seq(initial, next1, next2)(), Poll<std::string>("abc"));
+// }
+//
+// For a complete understanding of all possible uses and nuances of Seq look at
+// ThreeTypedPendingThens in file seq_test.cc
+
 namespace promise_detail {
 
 template <typename T>
@@ -76,12 +117,6 @@ using SeqIter = BasicSeqIter<SeqTraits, Iter, Factory, Argument>;
 
 }  // namespace promise_detail
 
-// Sequencing combinator.
-// Run the first promise.
-// Pass its result to the second, and run the returned promise.
-// Pass its result to the third, and run the returned promise.
-// etc
-// Return the final value.
 template <typename F>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline F Seq(F functor) {
   return functor;

data/src/core/lib/promise/sleep.cc

@@ -54,11 +54,11 @@ Poll<absl::Status> Sleep::operator()() {
 
 Sleep::ActiveClosure::ActiveClosure(Timestamp deadline)
     : waker_(GetContext<Activity>()->MakeOwningWaker()),
-      timer_handle_(GetContext<EventEngine>()->RunAfter(
-          deadline - Timestamp::Now(), this)) {}
+      event_engine_(GetContext<EventEngine>()->shared_from_this()),
+      timer_handle_(
+          event_engine_->RunAfter(deadline - Timestamp::Now(), this)) {}
 
 void Sleep::ActiveClosure::Run() {
-  ApplicationCallbackExecCtx callback_exec_ctx;
   ExecCtx exec_ctx;
   auto waker = std::move(waker_);
   if (Unref()) {

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

@@ -28,7 +28,19 @@
 
 namespace grpc_core {
 
-// Promise that sleeps until a deadline and then finishes.
+// Sleep is a Promise
+//
+// Instantiation :
+// We will need either a Timestamp or Duration object to instantiate this
+// promise.
+//
+// Return :
+// If this promise is Polled before the deadline, it returns Pending{}
+// If this promise if Polled after the deadline, it returns absl::OkStatus()
+//
+// If this Sleep promise is a part of an Activity/Party, the Activity/Party will
+// sleep when this Sleep promise is executed. And the the Activity/Party will be
+// woken up by the event engine when the deadline passes.
 class Sleep final {
  public:
   explicit Sleep(Timestamp deadline);
@@ -66,6 +78,7 @@ class Sleep final {
     Waker waker_;
     // One ref dropped by Run(), the other by Cancel().
     std::atomic<int> refs_{2};
+    std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
     grpc_event_engine::experimental::EventEngine::TaskHandle timer_handle_;
   };
 

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

@@ -17,13 +17,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <ostream>
 
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/promise/detail/status.h"
 
 namespace grpc_core {
@@ -232,7 +232,7 @@ class ValueOrFailure {
   ValueOrFailure(StatusFlag status) { CHECK(!status.ok()); }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure FromOptional(
-      absl::optional<T> value) {
+      std::optional<T> value) {
     return ValueOrFailure{std::move(value)};
   }
 
@@ -286,7 +286,7 @@ class ValueOrFailure {
   }
 
  private:
-  absl::optional<T> value_;
+  std::optional<T> value_;
 };
 
 template <typename T>
@@ -311,6 +311,12 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline T TakeValue(
   return std::move(value.value());
 }
 
+template <typename T>
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline T TakeValue(
+    absl::StatusOr<T>&& value) {
+  return std::move(*value);
+}
+
 template <typename T>
 struct StatusCastImpl<absl::StatusOr<T>, ValueOrFailure<T>> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(

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

@@ -33,6 +33,123 @@ namespace grpc_core {
 
 namespace promise_detail {
 
+// TryJoin Promise Combinator
+//
+// Input :
+// The TryJoin promise combinator takes as inputs one or more promises.
+//
+// Return :
+// Suppose you have three input promises
+// 1.  First promise returning type Poll<int>
+// 2.  Second promise returning type Poll<bool>
+// 3.  Third promise returning type Poll<double>
+// Then the TryJoin promise will have return type of either
+// Poll<absl::StatusOr<std::tuple<int, bool, double>>> or
+// Poll<ValueOrFailure<std::tuple<int, bool, double>>
+// The tuple have one entry corresponding to each input promise.
+// When you poll the TryJoin combinator composed of these 3 promises,
+// 1.  It will return Pending{} if even one promise in the input list of
+//     promises returns Pending{}.
+// 2.  It will return a failure status if any one of the input promises fails.
+// 2.  It will return a tuple if all the input promises are
+//     resolved and successful. The data types in the tuple correspond to the
+//     return types of the input promises in that order.
+//
+// Polling the TryJoin combinator works in the following way :
+// Polling this TryJoin combinator will make the pending promises run
+// serially, in order and on the same thread.
+// Each promise being executed either returns a value or Pending{}.
+// Each subsequent execution of the TryJoin will only execute the input promises
+// which are still pending. This mechanism ensures that no promise is executed
+// after it resolves, which is an essential requirement. If all the promises
+// have finished running successfully, the Join combinator will return a tuple
+// having the return value of each promise.
+//
+// Execution of promises in the TryJoin combinator will stop if any one promise
+// returns a failure status. If you want the promise execution to continue when
+// there is a failure , consider using Join promise combinator instead of the
+// TryJoin combinator.
+//
+// Example of TryJoin : Refer to try_join_test.cc
+// TEST(TryJoinTestBasic, TryJoinPendingFour) {
+//   std::string execution_order;
+//   bool pending_3 = true;
+//   bool pending_4 = true;
+//   bool pending_5 = true;
+//   bool pending_6 = true;
+//   auto try_join_combinator = TryJoin<absl::StatusOr>(
+//       [&execution_order, &pending_3]() mutable -> Poll<absl::StatusOr<int>> {
+//         absl::StrAppend(&execution_order, "3");
+//         if (pending_3) {
+//           absl::StrAppend(&execution_order, "P");
+//           return Pending{};
+//         }
+//         return 3;
+//       },
+//       [&execution_order, &pending_4]() mutable ->
+//       Poll<absl::StatusOr<double>> {
+//         absl::StrAppend(&execution_order, "4");
+//         if (pending_4) {
+//           absl::StrAppend(&execution_order, "P");
+//           return Pending{};
+//         }
+//         return 4.0;
+//       },
+//       [&execution_order,
+//        &pending_5]() mutable -> Poll<absl::StatusOr<std::string>> {
+//         absl::StrAppend(&execution_order, "5");
+//         if (pending_5) {
+//           absl::StrAppend(&execution_order, "P");
+//           return Pending{};
+//         }
+//         return "5";
+//       },
+//       [&execution_order, &pending_6]() mutable -> Poll<absl::StatusOr<int>> {
+//         absl::StrAppend(&execution_order, "6");
+//         if (pending_6) {
+//           absl::StrAppend(&execution_order, "P");
+//           return Pending{};
+//         }
+//         return 6;
+//       });
+//
+//   // Execution 1 : All promises are pending. All should be run once.
+//   Poll<absl::StatusOr<std::tuple<int, double, std::string, int>>> retval =
+//       try_join_combinator();
+//   EXPECT_TRUE(retval.pending());
+//   // All promises are Pending
+//   EXPECT_STREQ(execution_order.c_str(), "3P4P5P6P");
+//
+//   // Execution 2 : All promises should be run once. 3 gets resolved.
+//   execution_order.clear();
+//   pending_3 = false;
+//   retval = try_join_combinator();
+//   EXPECT_TRUE(retval.pending());
+//   EXPECT_STREQ(execution_order.c_str(), "34P5P6P");
+//
+//   // Execution 3 : All promises other than 3 should be run. 4 gets resolved.
+//   execution_order.clear();
+//   pending_4 = false;
+//   retval = try_join_combinator();
+//   EXPECT_TRUE(retval.pending());
+//   EXPECT_STREQ(execution_order.c_str(), "45P6P");  // 3 should not be re-run.
+//
+//   // Execution 4 : Order changed. 5 will still be pending. 6 will be
+//   resolved. execution_order.clear(); pending_6 = false; retval =
+//   try_join_combinator(); EXPECT_TRUE(retval.pending());
+//   EXPECT_STREQ(execution_order.c_str(), "5P6");
+//
+//   // Execution 5 : Only 5 should be run. And 5 gets resolved.
+//   execution_order.clear();
+//   pending_5 = false;
+//   retval = try_join_combinator();
+//   EXPECT_TRUE(retval.ready());  // All promises are resolved.
+//   EXPECT_STREQ(execution_order.c_str(), "5");
+//
+//   EXPECT_TRUE(retval.value().ok());  // All promises are a success.
+//   EXPECT_EQ(retval.value().value(), std::tuple(3, 4.0, "5", 6));
+// }
+
 // Extract the T from a StatusOr<T>
 template <typename T>
 T IntoResult(absl::StatusOr<T>* status) {
@@ -100,7 +217,7 @@ struct TryJoinTraits {
   }
   template <typename... A>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto FinalReturn(A&&... a) {
-    return Result<std::tuple<A...>>(std::make_tuple(std::forward<A>(a)...));
+    return Result<std::tuple<A...>>(std::tuple(std::forward<A>(a)...));
   }
 };
 
@@ -123,15 +240,12 @@ struct WrapInStatusOrTuple {
   template <typename T>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION R<std::tuple<T>> operator()(R<T> x) {
     if (!x.ok()) return x.status();
-    return std::make_tuple(std::move(*x));
+    return std::tuple(std::move(*x));
   }
 };
 
 }  // namespace promise_detail
 
-// Run all promises.
-// If any fail, cancel the rest and return the failure.
-// If all succeed, return Ok(tuple-of-results).
 template <template <typename> class R, typename... Promises>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::TryJoin<R,
                                                                     Promises...>

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

@@ -36,6 +36,45 @@ namespace grpc_core {
 
 namespace promise_detail {
 
+// TrySeq Promise combinator.
+//
+// Input :
+// 1. The TrySeq combinator needs minimum one promise as input.
+// 2. The first input to TrySeq combinator is a promise.
+// 3. The remaining inputs to TrySeq combinator are Promise Factories (functors
+// that return a promise). The input type of the Nth functor should be the
+// return value of the (N-1)th promise.
+// 4. Functors can return promises with return type any of the following :
+//    1. StatusOr<> to signal that a value is fed forward, or Status to
+//       indicate only success/failure. In the case of returning Status, the
+//       next functor in the chain takes no arguments.
+//    2. StatusFlag and ValueOrStatus can be return types if rich error
+//       information is not necessar. In this case the next functor in the chain
+//       takes no arguments.
+//
+// Return :
+// Polling the TrySeq Promise combinator returns Poll<StatusOr<T>> where T is
+// the type returned by the last promise in the list of input promises.
+//
+// Polling the TrySeq combinator works in the following way :
+// Run the first promise. If it returns Pending{}, nothing else is executed.
+// If the first promise returns a value, pass this result to the second functor,
+// and run the returned promise. If it returns Pending{}, nothing else is
+// executed. If it returns a value, pass this result to the third functor, and
+// run the returned promise. etc. Return the final value.
+//
+// If any of the promises in the TrySeq chain returns a failure status, TrySeq
+// will NOT proceed with the execution of the remaining promises. If you want
+// the execution to continue when a failure status is received, use the Seq
+// combinator instead.
+//
+// Promises in the TrySeq combinator are run in order, serially and on the same
+// thread.
+//
+// Example :
+// The unit tests (esp ThreeTypedPendingThens) in try_seq_test.cc provide all
+// possible permutations of how TrySeq combinator can be used.
+
 template <typename T, typename Ignored = void>
 struct TrySeqTraitsWithSfinae {
   using UnwrappedType = T;
@@ -256,18 +295,6 @@ struct TrySeqContainerResultTraits {
 
 }  // namespace promise_detail
 
-// Try a sequence of operations.
-// * Run the first functor as a promise.
-// * Feed its success result into the second functor to create a promise,
-//   then run that.
-// * ...
-// * Feed the second-final success result into the final functor to create a
-//   promise, then run that, with the overall success result being that
-//   promises success result.
-// If any step fails, fail everything.
-// Functors can return StatusOr<> to signal that a value is fed forward, or
-// Status to indicate only success/failure. In the case of returning Status,
-// the construction functors take no arguments.
 template <typename F>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline F TrySeq(F functor) {
   return functor;

data/src/core/lib/resource_quota/arena.h

@@ -30,6 +30,7 @@
 #include <stddef.h>
 
 #include <atomic>
+#include <cstddef>
 #include <iosfwd>
 #include <memory>
 #include <utility>
@@ -370,6 +371,84 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
   RefCountedPtr<ArenaFactory> arena_factory_;
 };
 
+// Arena backed single-producer-single-consumer queue
+// Based on implementation from
+// https://www.1024cores.net/home/lock-free-algorithms/queues/unbounded-spsc-queue
+template <typename T, bool kOptimizeAlignment = true>
+class ArenaSpsc {
+ public:
+  explicit ArenaSpsc(Arena* arena) : arena_(arena) {}
+
+  ~ArenaSpsc() {
+    while (Pop().has_value()) {
+    }
+  }
+
+  ArenaSpsc(const ArenaSpsc&) = delete;
+  ArenaSpsc& operator=(const ArenaSpsc&) = delete;
+
+  // Push `value` onto the queue; at most one thread can be calling this at a
+  // time.
+  void Push(T value) {
+    Node* n = AllocNode();
+    Construct(&n->value, std::move(value));
+    n->next.store(nullptr, std::memory_order_relaxed);
+    head_->next.store(n, std::memory_order_release);
+    head_ = n;
+  }
+
+  // Pop a value from the queue; at most one thread can be calling this at a
+  // time. If the queue was empty when called, returns nullopt.
+  std::optional<T> Pop() {
+    Node* n = tail_.load(std::memory_order_relaxed);
+    Node* next = n->next.load(std::memory_order_acquire);
+    if (next == nullptr) return std::nullopt;
+    T result = std::move(next->value);
+    Destruct(&next->value);
+    tail_.store(next, std::memory_order_release);
+    return result;
+  }
+
+ private:
+  struct Node {
+    Node() {}
+    ~Node() {}
+    explicit Node(std::nullptr_t) : next{nullptr} {}
+    std::atomic<Node*> next;
+    union {
+      T value;
+    };
+  };
+
+  Node* AllocNode() {
+    if (first_ != tail_copy_) {
+      Node* n = first_;
+      first_ = first_->next.load(std::memory_order_relaxed);
+      return n;
+    }
+    tail_copy_ = tail_.load(std::memory_order_acquire);
+    if (first_ != tail_copy_) {
+      Node* n = first_;
+      first_ = first_->next.load(std::memory_order_relaxed);
+      return n;
+    }
+    return arena_->New<Node>();
+  }
+
+  Arena* const arena_;
+  Node first_node_{nullptr};
+  // Accessed mainly by consumer, infrequently by producer
+  std::atomic<Node*> tail_{&first_node_};
+  // Ensure alignment on next cacheline to deliminate producer and consumer
+  // Head of queue
+  alignas(kOptimizeAlignment ? GPR_CACHELINE_SIZE
+                             : alignof(Node*)) Node* head_{&first_node_};
+  // Last unused node
+  Node* first_{&first_node_};
+  // Helper, points somewhere between first and tail
+  Node* tail_copy_{&first_node_};
+};
+
 // Arenas form a context for activities
 template <>
 struct ContextType<Arena> {};