grpc 1.53.1 → 1.54.0

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

@@ -0,0 +1,77 @@
+// 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_CANCEL_CALLBACK_H
+#define GRPC_SRC_CORE_LIB_PROMISE_CANCEL_CALLBACK_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "src/core/lib/promise/detail/promise_like.h"
+
+namespace grpc_core {
+
+namespace cancel_callback_detail {
+
+template <typename Fn>
+class Handler {
+ public:
+  explicit Handler(Fn fn) : fn_(std::move(fn)) {}
+  Handler(const Handler&) = delete;
+  Handler& operator=(const Handler&) = delete;
+  ~Handler() {
+    if (!done_) {
+      fn_();
+    }
+  }
+  Handler(Handler&& other) noexcept
+      : fn_(std::move(other.fn_)), done_(other.done_) {
+    other.done_ = true;
+  }
+  Handler& operator=(Handler&& other) noexcept {
+    fn_ = std::move(other.fn_);
+    done_ = other.done_;
+    other.done_ = true;
+  }
+
+  void Done() { done_ = true; }
+
+ private:
+  Fn fn_;
+  bool done_ = false;
+};
+
+}  // namespace cancel_callback_detail
+
+// Wrap main_fn so that it calls cancel_fn if the promise is destroyed prior to
+// completion.
+// Returns a promise with the same result type as main_fn.
+template <typename MainFn, typename CancelFn>
+auto OnCancel(MainFn main_fn, CancelFn cancel_fn) {
+  return [on_cancel =
+              cancel_callback_detail::Handler<CancelFn>(std::move(cancel_fn)),
+          main_fn = promise_detail::PromiseLike<MainFn>(
+              std::move(main_fn))]() mutable {
+    auto r = main_fn();
+    if (r.ready()) {
+      on_cancel.Done();
+    }
+    return r;
+  };
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_CANCEL_CALLBACK_H

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

@@ -167,7 +167,7 @@ auto CallNext(SeqState<Traits, I, Fs...>* state, T&& arg)
       &state->next_factory, std::forward<T>(arg));
 }
 
-// A sequence under stome traits for some set of callables Fs.
+// A sequence under some traits for some set of callables Fs.
 // Fs[0] should be a promise-like object that yields a value.
 // Fs[1..] should be promise-factory-like objects that take the value from the
 // previous step and yield a promise. Note that most of the machinery in

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

@@ -17,6 +17,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
 #include <type_traits>
 #include <utility>
 
@@ -106,6 +107,9 @@ class Curried {
  private:
   GPR_NO_UNIQUE_ADDRESS F f_;
   GPR_NO_UNIQUE_ADDRESS Arg arg_;
+#ifndef NDEBUG
+  std::unique_ptr<int> asan_canary_ = std::make_unique<int>(0);
+#endif
 };
 
 // Promote a callable(A) -> T | Poll<T> to a PromiseFactory(A) -> Promise<T> by

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

@@ -0,0 +1,176 @@
+// 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_FOR_EACH_H
+#define GRPC_SRC_CORE_LIB_PROMISE_FOR_EACH_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.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/promise/activity.h"
+#include "src/core/lib/promise/detail/promise_factory.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/trace.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;
+  };
+
+  std::string DebugTag() {
+    return absl::StrCat(Activity::current()->DebugTag(), " FOR_EACH[0x",
+                        reinterpret_cast<uintptr_t>(this), "]: ");
+  }
+
+  Poll<Result> PollReaderNext() {
+    if (grpc_trace_promise_primitives.enabled()) {
+      gpr_log(GPR_DEBUG, "%s PollReaderNext", DebugTag().c_str());
+    }
+    auto r = reader_next_();
+    if (auto* p = r.value_if_ready()) {
+      if (grpc_trace_promise_primitives.enabled()) {
+        gpr_log(GPR_DEBUG, "%s PollReaderNext: got has_value=%s",
+                DebugTag().c_str(), p->has_value() ? "true" : "false");
+      }
+      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() {
+    if (grpc_trace_promise_primitives.enabled()) {
+      gpr_log(GPR_DEBUG, "%s PollAction", DebugTag().c_str());
+    }
+    auto r = in_action_.promise();
+    if (auto* p = r.value_if_ready()) {
+      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_SRC_CORE_LIB_PROMISE_FOR_EACH_H

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

@@ -17,7 +17,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
 #include <type_traits>
+#include <utility>
 
 #include "absl/status/statusor.h"
 #include "absl/types/variant.h"
@@ -162,6 +164,9 @@ class If<bool, T, F> {
   }
 
   Poll<Result> operator()() {
+#ifndef NDEBUG
+    asan_canary_ = std::make_unique<int>(1 + *asan_canary_);
+#endif
     if (condition_) {
       return if_true_();
     } else {
@@ -175,6 +180,10 @@ class If<bool, T, F> {
     TruePromise if_true_;
     FalsePromise if_false_;
   };
+  // Make failure to destruct show up in ASAN builds.
+#ifndef NDEBUG
+  std::unique_ptr<int> asan_canary_ = std::make_unique<int>(0);
+#endif
 };
 
 }  // namespace promise_detail

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

@@ -89,6 +89,10 @@ class InterceptorList {
    public:
     RunPromise(size_t memory_required, Map* factory, absl::optional<T> value) {
       if (!value.has_value() || factory == nullptr) {
+        if (grpc_trace_promise_primitives.enabled()) {
+          gpr_log(GPR_DEBUG,
+                  "InterceptorList::RunPromise[%p]: create immediate", this);
+        }
         is_immediately_resolved_ = true;
         Construct(&result_, std::move(value));
       } else {
@@ -96,10 +100,18 @@ class InterceptorList {
         Construct(&async_resolution_, memory_required);
         factory->MakePromise(std::move(*value), async_resolution_.space.get());
         async_resolution_.current_factory = factory;
+        if (grpc_trace_promise_primitives.enabled()) {
+          gpr_log(GPR_DEBUG,
+                  "InterceptorList::RunPromise[%p]: create async; mem=%p", this,
+                  async_resolution_.space.get());
+        }
       }
     }
 
     ~RunPromise() {
+      if (grpc_trace_promise_primitives.enabled()) {
+        gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: destroy", this);
+      }
       if (is_immediately_resolved_) {
         Destruct(&result_);
       } else {
@@ -116,6 +128,10 @@ class InterceptorList {
 
     RunPromise(RunPromise&& other) noexcept
         : is_immediately_resolved_(other.is_immediately_resolved_) {
+      if (grpc_trace_promise_primitives.enabled()) {
+        gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: move from %p",
+                this, &other);
+      }
       if (is_immediately_resolved_) {
         Construct(&result_, std::move(other.result_));
       } else {
@@ -127,7 +143,7 @@ class InterceptorList {
 
     Poll<absl::optional<T>> operator()() {
       if (grpc_trace_promise_primitives.enabled()) {
-        gpr_log(GPR_DEBUG, "InterceptorList::RunPromise: %s",
+        gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: %s", this,
                 DebugString().c_str());
       }
       if (is_immediately_resolved_) return std::move(result_);
@@ -139,7 +155,12 @@ class InterceptorList {
               async_resolution_.space.get());
           async_resolution_.current_factory =
               async_resolution_.current_factory->next();
-          if (async_resolution_.current_factory == nullptr || !p->has_value()) {
+          if (!p->has_value()) async_resolution_.current_factory = nullptr;
+          if (grpc_trace_promise_primitives.enabled()) {
+            gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: %s", this,
+                    DebugString().c_str());
+          }
+          if (async_resolution_.current_factory == nullptr) {
             return std::move(*p);
           }
           async_resolution_.current_factory->MakePromise(

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

@@ -19,6 +19,7 @@
 
 #include <stdint.h>
 
+#include <atomic>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -29,7 +30,6 @@
 
 #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"
 
@@ -61,13 +61,14 @@ class Latch {
   }
 
   // Produce a promise to wait for a value from this latch.
+  // Moves the result out of the latch.
   auto Wait() {
 #ifndef NDEBUG
     has_had_waiters_ = true;
 #endif
     return [this]() -> Poll<T> {
       if (grpc_trace_promise_primitives.enabled()) {
-        gpr_log(GPR_INFO, "%sPollWait %s", DebugTag().c_str(),
+        gpr_log(GPR_INFO, "%sWait %s", DebugTag().c_str(),
                 StateString().c_str());
       }
       if (has_value_) {
@@ -78,6 +79,25 @@ class Latch {
     };
   }
 
+  // Produce a promise to wait for a value from this latch.
+  // Copies the result out of the latch.
+  auto WaitAndCopy() {
+#ifndef NDEBUG
+    has_had_waiters_ = true;
+#endif
+    return [this]() -> Poll<T> {
+      if (grpc_trace_promise_primitives.enabled()) {
+        gpr_log(GPR_INFO, "%sWaitAndCopy %s", DebugTag().c_str(),
+                StateString().c_str());
+      }
+      if (has_value_) {
+        return value_;
+      } else {
+        return waiter_.pending();
+      }
+    };
+  }
+
   // Set the value of the latch. Can only be called once.
   void Set(T value) {
     if (grpc_trace_promise_primitives.enabled()) {
@@ -89,6 +109,8 @@ class Latch {
     waiter_.Wake();
   }
 
+  bool is_set() const { return has_value_; }
+
  private:
   std::string DebugTag() {
     return absl::StrCat(Activity::current()->DebugTag(), " LATCH[0x",
@@ -165,7 +187,7 @@ class Latch<void> {
 
  private:
   std::string DebugTag() {
-    return absl::StrCat(Activity::current()->DebugTag(), " LATCH[0x",
+    return absl::StrCat(Activity::current()->DebugTag(), " LATCH(void)[0x",
                         reinterpret_cast<uintptr_t>(this), "]: ");
   }
 
@@ -183,6 +205,70 @@ class Latch<void> {
   IntraActivityWaiter waiter_;
 };
 
+// A Latch that can have its value observed by outside threads, but only waited
+// upon from inside a single activity.
+template <typename T>
+class ExternallyObservableLatch;
+
+template <>
+class ExternallyObservableLatch<void> {
+ public:
+  ExternallyObservableLatch() = default;
+  ExternallyObservableLatch(const ExternallyObservableLatch&) = delete;
+  ExternallyObservableLatch& operator=(const ExternallyObservableLatch&) =
+      delete;
+
+  // Produce a promise to wait for this latch.
+  auto Wait() {
+    return [this]() -> Poll<Empty> {
+      if (grpc_trace_promise_primitives.enabled()) {
+        gpr_log(GPR_INFO, "%sPollWait %s", DebugTag().c_str(),
+                StateString().c_str());
+      }
+      if (IsSet()) {
+        return Empty{};
+      } else {
+        return waiter_.pending();
+      }
+    };
+  }
+
+  // Set the latch.
+  void Set() {
+    if (grpc_trace_promise_primitives.enabled()) {
+      gpr_log(GPR_INFO, "%sSet %s", DebugTag().c_str(), StateString().c_str());
+    }
+    is_set_.store(true, std::memory_order_relaxed);
+    waiter_.Wake();
+  }
+
+  bool IsSet() const { return is_set_.load(std::memory_order_relaxed); }
+
+  void Reset() {
+    if (grpc_trace_promise_primitives.enabled()) {
+      gpr_log(GPR_INFO, "%sReset %s", DebugTag().c_str(),
+              StateString().c_str());
+    }
+    is_set_.store(false, std::memory_order_relaxed);
+  }
+
+ private:
+  std::string DebugTag() {
+    return absl::StrCat(Activity::current()->DebugTag(), " LATCH(void)[0x",
+                        reinterpret_cast<uintptr_t>(this), "]: ");
+  }
+
+  std::string StateString() {
+    return absl::StrCat(
+        "is_set:", is_set_.load(std::memory_order_relaxed) ? "true" : "false",
+        " waiter:", waiter_.DebugString());
+  }
+
+  // True if we have a value set, false otherwise.
+  std::atomic<bool> is_set_{false};
+  IntraActivityWaiter waiter_;
+};
+
 template <typename T>
 using LatchWaitPromise = decltype(std::declval<Latch<T>>().Wait());
 

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

@@ -17,14 +17,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <new>
 #include <type_traits>
-#include <utility>
 
 #include "absl/status/status.h"
 #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/poll.h"
 
@@ -83,17 +82,21 @@ class Loop {
  public:
   using Result = typename LoopTraits<PromiseResult>::Result;
 
-  explicit Loop(F f) : factory_(std::move(f)), promise_(factory_.Make()) {}
-  ~Loop() { promise_.~PromiseType(); }
+  explicit Loop(F f) : factory_(std::move(f)) {}
+  ~Loop() {
+    if (started_) Destruct(&promise_);
+  }
 
-  Loop(Loop&& loop) noexcept
-      : factory_(std::move(loop.factory_)),
-        promise_(std::move(loop.promise_)) {}
+  Loop(Loop&& loop) noexcept : factory_(std::move(loop.factory_)) {}
 
   Loop(const Loop& loop) = delete;
   Loop& operator=(const Loop& loop) = delete;
 
   Poll<Result> operator()() {
+    if (!started_) {
+      started_ = true;
+      Construct(&promise_, factory_.Make());
+    }
     while (true) {
       // Poll the inner promise.
       auto promise_result = promise_();
@@ -103,8 +106,8 @@ class Loop {
         //  from our factory.
         auto lc = LoopTraits<PromiseResult>::ToLoopCtl(*p);
         if (absl::holds_alternative<Continue>(lc)) {
-          promise_.~PromiseType();
-          new (&promise_) PromiseType(factory_.Make());
+          Destruct(&promise_);
+          Construct(&promise_, factory_.Make());
           continue;
         }
         //  - otherwise there's our result... return it out.
@@ -121,6 +124,7 @@ class Loop {
   GPR_NO_UNIQUE_ADDRESS union {
     GPR_NO_UNIQUE_ADDRESS PromiseType promise_;
   };
+  bool started_ = false;
 };
 
 }  // namespace promise_detail

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

@@ -39,6 +39,13 @@ class Map {
   Map(Promise promise, Fn fn)
       : promise_(std::move(promise)), fn_(std::move(fn)) {}
 
+  Map(const Map&) = delete;
+  Map& operator=(const Map&) = delete;
+  // NOLINTNEXTLINE(performance-noexcept-move-constructor): clang6 bug
+  Map(Map&& other) = default;
+  // NOLINTNEXTLINE(performance-noexcept-move-constructor): clang6 bug
+  Map& operator=(Map&& other) = default;
+
   using PromiseResult = typename PromiseLike<Promise>::Result;
   using Result =
       RemoveCVRef<decltype(std::declval<Fn>()(std::declval<PromiseResult>()))>;