grpc 1.52.0.pre2 → 1.53.0.pre2

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

@@ -1,155 +0,0 @@
-// 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_CORE_LIB_PROMISE_FOR_EACH_H
-#define GRPC_CORE_LIB_PROMISE_FOR_EACH_H
-
-#include <grpc/support/port_platform.h>
-
-#include <type_traits>
-#include <utility>
-
-#include "absl/status/status.h"
-#include "absl/types/variant.h"
-
-#include <grpc/support/log.h>
-
-#include "src/core/lib/gprpp/construct_destruct.h"
-#include "src/core/lib/promise/detail/promise_factory.h"
-#include "src/core/lib/promise/poll.h"
-
-namespace grpc_core {
-
-namespace for_each_detail {
-
-// Done creates statuses for the end of the iteration. It's templated on the
-// type of the result of the ForEach loop, so that we can introduce new types
-// easily.
-template <typename T>
-struct Done;
-
-template <>
-struct Done<absl::Status> {
-  static absl::Status Make() { return absl::OkStatus(); }
-};
-
-template <typename Reader, typename Action>
-class ForEach {
- private:
-  using ReaderNext = decltype(std::declval<Reader>().Next());
-  using ReaderResult =
-      typename PollTraits<decltype(std::declval<ReaderNext>()())>::Type;
-  using ReaderResultValue = typename ReaderResult::value_type;
-  using ActionFactory =
-      promise_detail::RepeatedPromiseFactory<ReaderResultValue, Action>;
-  using ActionPromise = typename ActionFactory::Promise;
-
- public:
-  using Result =
-      typename PollTraits<decltype(std::declval<ActionPromise>()())>::Type;
-  ForEach(Reader reader, Action action)
-      : reader_(std::move(reader)), action_factory_(std::move(action)) {
-    Construct(&reader_next_, reader_.Next());
-  }
-  ~ForEach() {
-    if (reading_next_) {
-      Destruct(&reader_next_);
-    } else {
-      Destruct(&in_action_);
-    }
-  }
-
-  ForEach(const ForEach&) = delete;
-  ForEach& operator=(const ForEach&) = delete;
-  ForEach(ForEach&& other) noexcept
-      : reader_(std::move(other.reader_)),
-        action_factory_(std::move(other.action_factory_)) {
-    GPR_DEBUG_ASSERT(reading_next_);
-    GPR_DEBUG_ASSERT(other.reading_next_);
-    Construct(&reader_next_, std::move(other.reader_next_));
-  }
-  ForEach& operator=(ForEach&& other) noexcept {
-    GPR_DEBUG_ASSERT(reading_next_);
-    GPR_DEBUG_ASSERT(other.reading_next_);
-    reader_ = std::move(other.reader_);
-    action_factory_ = std::move(other.action_factory_);
-    reader_next_ = std::move(other.reader_next_);
-    return *this;
-  }
-
-  Poll<Result> operator()() {
-    if (reading_next_) return PollReaderNext();
-    return PollAction();
-  }
-
- private:
-  struct InAction {
-    InAction(ActionPromise promise, ReaderResult result)
-        : promise(std::move(promise)), result(std::move(result)) {}
-    ActionPromise promise;
-    ReaderResult result;
-  };
-
-  Poll<Result> PollReaderNext() {
-    auto r = reader_next_();
-    if (auto* p = absl::get_if<kPollReadyIdx>(&r)) {
-      if (p->has_value()) {
-        Destruct(&reader_next_);
-        auto action = action_factory_.Make(std::move(**p));
-        Construct(&in_action_, std::move(action), std::move(*p));
-        reading_next_ = false;
-        return PollAction();
-      } else {
-        return Done<Result>::Make();
-      }
-    }
-    return Pending();
-  }
-
-  Poll<Result> PollAction() {
-    auto r = in_action_.promise();
-    if (auto* p = absl::get_if<kPollReadyIdx>(&r)) {
-      if (p->ok()) {
-        Destruct(&in_action_);
-        Construct(&reader_next_, reader_.Next());
-        reading_next_ = true;
-        return PollReaderNext();
-      } else {
-        return std::move(*p);
-      }
-    }
-    return Pending();
-  }
-
-  GPR_NO_UNIQUE_ADDRESS Reader reader_;
-  GPR_NO_UNIQUE_ADDRESS ActionFactory action_factory_;
-  bool reading_next_ = true;
-  union {
-    ReaderNext reader_next_;
-    InAction in_action_;
-  };
-};
-
-}  // namespace for_each_detail
-
-/// For each item acquired by calling Reader::Next, run the promise Action.
-template <typename Reader, typename Action>
-for_each_detail::ForEach<Reader, Action> ForEach(Reader reader, Action action) {
-  return for_each_detail::ForEach<Reader, Action>(std::move(reader),
-                                                  std::move(action));
-}
-
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_PROMISE_FOR_EACH_H

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

@@ -1,88 +0,0 @@
-// 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_CORE_LIB_PROMISE_MAP_PIPE_H
-#define GRPC_CORE_LIB_PROMISE_MAP_PIPE_H
-
-#include <grpc/support/port_platform.h>
-
-#include "absl/status/status.h"
-
-#include "src/core/lib/promise/detail/promise_factory.h"
-#include "src/core/lib/promise/for_each.h"
-#include "src/core/lib/promise/map.h"
-#include "src/core/lib/promise/pipe.h"
-#include "src/core/lib/promise/try_seq.h"
-
-namespace grpc_core {
-
-// Apply a (possibly async) mapping function to src, and output into dst.
-//
-// In psuedo-code:
-// for each element in wait_for src.Next:
-//   x = wait_for filter_factory(element)
-//   wait_for dst.Push(x)
-template <typename T, typename Filter>
-auto MapPipe(PipeReceiver<T> src, PipeSender<T> dst, Filter filter_factory) {
-  return ForEach(
-      std::move(src),
-      [filter_factory = promise_detail::RepeatedPromiseFactory<T, Filter>(
-           std::move(filter_factory)),
-       dst = std::move(dst)](T t) mutable {
-        return TrySeq(filter_factory.Make(std::move(t)), [&dst](T t) {
-          return Map(dst.Push(std::move(t)), [](bool successful_push) {
-            if (successful_push) {
-              return absl::OkStatus();
-            }
-            return absl::CancelledError();
-          });
-        });
-      });
-}
-
-// Helper to intecept a pipe and apply a mapping function.
-// Each of the `Intercept` constructors will take a PipeSender or PipeReceiver,
-// construct a new pipe, and then replace the passed in pipe with its new end.
-// In this way it can interject logic per-element.
-// Next, the TakeAndRun function will return a promise that can be run to apply
-// a mapping promise to each element of the pipe.
-template <typename T>
-class PipeMapper {
- public:
-  static PipeMapper Intercept(PipeSender<T>& intercept_sender) {
-    PipeMapper<T> r;
-    r.interceptor_.sender.Swap(&intercept_sender);
-    return r;
-  }
-
-  static PipeMapper Intercept(PipeReceiver<T>& intercept_receiver) {
-    PipeMapper<T> r;
-    r.interceptor_.receiver.Swap(&intercept_receiver);
-    return r;
-  }
-
-  template <typename Filter>
-  auto TakeAndRun(Filter filter) {
-    return MapPipe(std::move(interceptor_.receiver),
-                   std::move(interceptor_.sender), std::move(filter));
-  }
-
- private:
-  PipeMapper() = default;
-  Pipe<T> interceptor_;
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_PROMISE_MAP_PIPE_H

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

@@ -1,342 +0,0 @@
-// 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_CORE_LIB_PROMISE_TRY_CONCURRENTLY_H
-#define GRPC_CORE_LIB_PROMISE_TRY_CONCURRENTLY_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stddef.h>
-
-#include <cstdint>
-#include <type_traits>
-#include <utility>
-
-#include "absl/types/variant.h"
-
-#include <grpc/support/log.h>
-
-#include "src/core/lib/gprpp/construct_destruct.h"
-#include "src/core/lib/promise/detail/promise_like.h"
-#include "src/core/lib/promise/detail/status.h"
-#include "src/core/lib/promise/poll.h"
-
-namespace grpc_core {
-
-namespace promise_detail {
-
-template <typename Promise>
-struct Necessary {
-  PromiseLike<Promise> promise;
-  static constexpr bool must_complete() { return true; }
-};
-
-template <typename Promise>
-struct Helper {
-  PromiseLike<Promise> promise;
-  static constexpr bool must_complete() { return false; }
-};
-
-// A set of promises that can be polled concurrently.
-// Fuses them when completed (that is, destroys the promise and records it
-// completed).
-// Relies on an external bit field to handle the recording: this saves a bunch
-// of space, but means the implementation of this type is weird: it's really
-// super tied to TryConcurrently and no attempt should be made to use this
-// independently.
-template <typename... Ts>
-class FusedSet;
-
-template <typename T, typename... Ts>
-class FusedSet<T, Ts...> : public FusedSet<Ts...> {
- public:
-  explicit FusedSet(T&& x, Ts&&... xs)
-      : FusedSet<Ts...>(std::forward<T>(xs)...) {
-    Construct(&wrapper_, std::forward<T>(x));
-  }
-  explicit FusedSet(T&& x, FusedSet<Ts...>&& xs)
-      : FusedSet<Ts...>(std::forward<FusedSet<Ts...>>(xs)) {
-    Construct(&wrapper_, std::forward<T>(x));
-  }
-  // Empty destructor: consumers must call Destroy() to ensure cleanup occurs
-  ~FusedSet() {}
-
-  FusedSet(const FusedSet&) = delete;
-  FusedSet& operator=(const FusedSet&) = delete;
-
-  // Assumes all 'done_bits' for other are 0 and will be set to 1
-  FusedSet(FusedSet&& other) noexcept : FusedSet<Ts...>(std::move(other)) {
-    Construct(&wrapper_, std::move(other.wrapper_));
-    Destruct(&other.wrapper_);
-  }
-
-  static constexpr size_t Size() { return 1 + sizeof...(Ts); }
-
-  static constexpr uint8_t NecessaryBits() {
-    return (T::must_complete() ? 1 : 0) |
-           (FusedSet<Ts...>::NecessaryBits() << 1);
-  }
-
-  template <int kDoneBit>
-  void Destroy(uint8_t done_bits) {
-    if ((done_bits & (1 << kDoneBit)) == 0) {
-      Destruct(&wrapper_);
-    }
-    FusedSet<Ts...>::template Destroy<kDoneBit + 1>(done_bits);
-  }
-
-  template <typename Result, int kDoneBit>
-  Poll<Result> Run(uint8_t& done_bits) {
-    if ((done_bits & (1 << kDoneBit)) == 0) {
-      auto p = wrapper_.promise();
-      if (auto* status = absl::get_if<kPollReadyIdx>(&p)) {
-        done_bits |= (1 << kDoneBit);
-        Destruct(&wrapper_);
-        if (!IsStatusOk(*status)) {
-          return StatusCast<Result>(std::move(*status));
-        }
-      }
-    }
-    return FusedSet<Ts...>::template Run<Result, kDoneBit + 1>(done_bits);
-  }
-
-  template <typename P>
-  FusedSet<P, T, Ts...> With(P x) {
-    return FusedSet<P, T, Ts...>(std::move(x), std::move(*this));
-  }
-
- private:
-  union {
-    T wrapper_;
-  };
-};
-
-template <>
-class FusedSet<> {
- public:
-  static constexpr size_t Size() { return 0; }
-  static constexpr uint8_t NecessaryBits() { return 0; }
-
-  template <typename Result, int kDoneBit>
-  Poll<Result> Run(uint8_t) {
-    return Pending{};
-  }
-  template <int kDoneBit>
-  void Destroy(uint8_t) {}
-
-  template <typename P>
-  FusedSet<P> With(P x) {
-    return FusedSet<P>(std::move(x));
-  }
-};
-
-template <typename Main, typename PreMain, typename PostMain>
-class TryConcurrently {
- public:
-  TryConcurrently(Main main, PreMain pre_main, PostMain post_main)
-      : done_bits_(0),
-        pre_main_(std::move(pre_main)),
-        post_main_(std::move(post_main)) {
-    Construct(&main_, std::move(main));
-  }
-
-  TryConcurrently(const TryConcurrently&) = delete;
-  TryConcurrently& operator=(const TryConcurrently&) = delete;
-  TryConcurrently(TryConcurrently&& other) noexcept
-      : done_bits_(0),
-        pre_main_(std::move(other.pre_main_)),
-        post_main_(std::move(other.post_main_)) {
-    GPR_DEBUG_ASSERT(other.done_bits_ == 0);
-    other.done_bits_ = HelperBits();
-    Construct(&main_, std::move(other.main_));
-  }
-  TryConcurrently& operator=(TryConcurrently&& other) noexcept {
-    GPR_DEBUG_ASSERT(other.done_bits_ == 0);
-    done_bits_ = 0;
-    other.done_bits_ = HelperBits();
-    pre_main_ = std::move(other.pre_main_);
-    post_main_ = std::move(other.post_main_);
-    Construct(&main_, std::move(other.main_));
-    return *this;
-  }
-
-  ~TryConcurrently() {
-    if (done_bits_ & 1) {
-      Destruct(&result_);
-    } else {
-      Destruct(&main_);
-    }
-    pre_main_.template Destroy<1>(done_bits_);
-    post_main_.template Destroy<1 + PreMain::Size()>(done_bits_);
-  }
-
-  using Result =
-      typename PollTraits<decltype(std::declval<PromiseLike<Main>>()())>::Type;
-
-  Poll<Result> operator()() {
-    auto r = pre_main_.template Run<Result, 1>(done_bits_);
-    if (auto* status = absl::get_if<Result>(&r)) {
-      GPR_DEBUG_ASSERT(!IsStatusOk(*status));
-      return std::move(*status);
-    }
-    if ((done_bits_ & 1) == 0) {
-      auto p = main_();
-      if (auto* status = absl::get_if<kPollReadyIdx>(&p)) {
-        done_bits_ |= 1;
-        Destruct(&main_);
-        Construct(&result_, std::move(*status));
-      }
-    }
-    r = post_main_.template Run<Result, 1 + PreMain::Size()>(done_bits_);
-    if (auto* status = absl::get_if<Result>(&r)) {
-      GPR_DEBUG_ASSERT(!IsStatusOk(*status));
-      return std::move(*status);
-    }
-    if ((done_bits_ & NecessaryBits()) == NecessaryBits()) {
-      return std::move(result_);
-    }
-    return Pending{};
-  }
-
-  template <typename P>
-  auto NecessaryPush(P p);
-  template <typename P>
-  auto NecessaryPull(P p);
-  template <typename P>
-  auto Push(P p);
-  template <typename P>
-  auto Pull(P p);
-
- private:
-  // Bitmask for done_bits_ specifying which promises must be completed prior to
-  // returning ok.
-  constexpr uint8_t NecessaryBits() {
-    return 1 | (PreMain::NecessaryBits() << 1) |
-           (PostMain::NecessaryBits() << (1 + PreMain::Size()));
-  }
-  // Bitmask for done_bits_ specifying what all of the promises being complete
-  // would look like.
-  constexpr uint8_t AllBits() {
-    return (1 << (1 + PreMain::Size() + PostMain::Size())) - 1;
-  }
-  // Bitmask of done_bits_ specifying which bits correspond to helper promises -
-  // that is all promises that are not the main one.
-  constexpr uint8_t HelperBits() { return AllBits() ^ 1; }
-
-  // done_bits signifies which operations have completed.
-  // Bit 0 is set if main_ has completed.
-  // The next higher bits correspond one per pre-main promise.
-  // The next higher bits correspond one per post-main promise.
-  // So, going from most significant bit to least significant:
-  // +--------------+-------------+--------+
-  // |post_main bits|pre_main bits|main bit|
-  // +--------------+-------------+--------+
-  uint8_t done_bits_;
-  PreMain pre_main_;
-  union {
-    PromiseLike<Main> main_;
-    Result result_;
-  };
-  PostMain post_main_;
-};
-
-template <typename Main, typename PreMain, typename PostMain>
-auto MakeTryConcurrently(Main&& main, PreMain&& pre_main,
-                         PostMain&& post_main) {
-  return TryConcurrently<Main, PreMain, PostMain>(
-      std::forward<Main>(main), std::forward<PreMain>(pre_main),
-      std::forward<PostMain>(post_main));
-}
-
-template <typename Main, typename PreMain, typename PostMain>
-template <typename P>
-auto TryConcurrently<Main, PreMain, PostMain>::NecessaryPush(P p) {
-  GPR_DEBUG_ASSERT(done_bits_ == 0);
-  done_bits_ = HelperBits();
-  return MakeTryConcurrently(std::move(main_),
-                             pre_main_.With(Necessary<P>{std::move(p)}),
-                             std::move(post_main_));
-}
-
-template <typename Main, typename PreMain, typename PostMain>
-template <typename P>
-auto TryConcurrently<Main, PreMain, PostMain>::NecessaryPull(P p) {
-  GPR_DEBUG_ASSERT(done_bits_ == 0);
-  done_bits_ = HelperBits();
-  return MakeTryConcurrently(std::move(main_), std::move(pre_main_),
-                             post_main_.With(Necessary<P>{std::move(p)}));
-}
-
-template <typename Main, typename PreMain, typename PostMain>
-template <typename P>
-auto TryConcurrently<Main, PreMain, PostMain>::Push(P p) {
-  GPR_DEBUG_ASSERT(done_bits_ == 0);
-  done_bits_ = HelperBits();
-  return MakeTryConcurrently(std::move(main_),
-                             pre_main_.With(Helper<P>{std::move(p)}),
-                             std::move(post_main_));
-}
-
-template <typename Main, typename PreMain, typename PostMain>
-template <typename P>
-auto TryConcurrently<Main, PreMain, PostMain>::Pull(P p) {
-  GPR_DEBUG_ASSERT(done_bits_ == 0);
-  done_bits_ = HelperBits();
-  return MakeTryConcurrently(std::move(main_), std::move(pre_main_),
-                             post_main_.With(Helper<P>{std::move(p)}));
-}
-
-}  // namespace promise_detail
-
-// TryConcurrently runs a set of promises concurrently.
-// There is a structure to the promises:
-//  - A 'main' promise dominates the others - it must complete before the
-//    overall promise successfully completes. Its result is chosen in the event
-//    of successful completion.
-//  - A set of (optional) push and pull promises to aid main. Push promises are
-//    polled before main, pull promises are polled after. In this way we can
-//    avoid overall wakeup churn - sending a message will tend to push things
-//    down the promise tree as its polled, so that send should be in a push
-//    promise - then as the main promise is polled and it calls into things
-//    lower in the stack they'll already see things there (this reasoning holds
-//    for receiving things and the pull promises too!).
-//  - Each push and pull promise is either necessary or optional.
-//    Necessary promises must complete successfully before the overall promise
-//    completes. Optional promises will just be cancelled once the main promise
-//    completes and any necessary helpers.
-//  - If any of the promises fail, the overall promise fails immediately.
-// API:
-//  This function, TryConcurrently, is used to create a TryConcurrently promise.
-//  It takes a single argument, being the main promise. That promise also has
-//  a set of methods for attaching push and pull promises. The act of attachment
-//  returns a new TryConcurrently promise with previous contained promises moved
-//  out.
-//  The methods exposed:
-//  - Push, NecessaryPush: attach a push promise (with the first variant being
-//                         optional, the second necessary).
-//  - Pull, NecessaryPull: attach a pull promise, with variants as above.
-// Example:
-//  TryConcurrently(call_next_filter(std::move(call_args)))
-//     .Push(send_messages_promise)
-//     .Pull(recv_messages_promise)
-template <typename Main>
-auto TryConcurrently(Main main) {
-  return promise_detail::MakeTryConcurrently(std::move(main),
-                                             promise_detail::FusedSet<>(),
-                                             promise_detail::FusedSet<>());
-}
-
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_PROMISE_TRY_CONCURRENTLY_H