grpc 1.52.2 → 1.53.0.pre2

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_ACTIVITY_H
-#define GRPC_CORE_LIB_PROMISE_ACTIVITY_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_ACTIVITY_H
+#define GRPC_SRC_CORE_LIB_PROMISE_ACTIVITY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -28,8 +28,6 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
-#include "absl/types/variant.h"
-#include "absl/utility/utility.h"
 
 #include <grpc/support/log.h>
 
@@ -40,7 +38,6 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/detail/status.h"
-#include "src/core/lib/promise/poll.h"
 
 namespace grpc_core {
 
@@ -51,12 +48,14 @@ class Wakeable {
  public:
   // Wake up the underlying activity.
   // After calling, this Wakeable cannot be used again.
-  virtual void Wakeup() = 0;
+  // arg comes from the Waker object and allows one Wakeable instance to be used
+  // for multiple disjoint subparts of an Activity.
+  virtual void Wakeup(void* arg) = 0;
   // Drop this wakeable without waking up the underlying activity.
-  virtual void Drop() = 0;
+  virtual void Drop(void* arg) = 0;
 
   // Return the underlying activity debug tag, or "<unknown>" if not available.
-  virtual std::string ActivityDebugTag() const = 0;
+  virtual std::string ActivityDebugTag(void* arg) const = 0;
 
  protected:
   inline ~Wakeable() {}
@@ -64,91 +63,78 @@ class Wakeable {
 
 namespace promise_detail {
 struct Unwakeable final : public Wakeable {
-  void Wakeup() override {}
-  void Drop() override {}
-  std::string ActivityDebugTag() const override;
+  void Wakeup(void*) override {}
+  void Drop(void*) override {}
+  std::string ActivityDebugTag(void*) const override;
 };
 static Unwakeable* unwakeable() {
   return NoDestructSingleton<Unwakeable>::Get();
 }
 }  // namespace promise_detail
 
-class AtomicWaker;
-
 // An owning reference to a Wakeable.
 // This type is non-copyable but movable.
 class Waker {
  public:
-  explicit Waker(Wakeable* wakeable) : wakeable_(wakeable) {}
-  Waker() : Waker(promise_detail::unwakeable()) {}
-  ~Waker() { wakeable_->Drop(); }
+  Waker(Wakeable* wakeable, void* arg) : wakeable_and_arg_{wakeable, arg} {}
+  Waker() : Waker(promise_detail::unwakeable(), nullptr) {}
+  ~Waker() { wakeable_and_arg_.Drop(); }
   Waker(const Waker&) = delete;
   Waker& operator=(const Waker&) = delete;
-  Waker(Waker&& other) noexcept : wakeable_(other.Take()) {}
+  Waker(Waker&& other) noexcept : wakeable_and_arg_(other.Take()) {}
   Waker& operator=(Waker&& other) noexcept {
-    std::swap(wakeable_, other.wakeable_);
+    std::swap(wakeable_and_arg_, other.wakeable_and_arg_);
     return *this;
   }
 
   // Wake the underlying activity.
-  void Wakeup() { Take()->Wakeup(); }
+  void Wakeup() { Take().Wakeup(); }
 
   template <typename H>
   friend H AbslHashValue(H h, const Waker& w) {
-    return H::combine(std::move(h), w.wakeable_);
+    return H::combine(H::combine(std::move(h), w.wakeable_and_arg_.wakeable),
+                      w.wakeable_and_arg_.arg);
   }
 
   bool operator==(const Waker& other) const noexcept {
-    return wakeable_ == other.wakeable_;
+    return wakeable_and_arg_ == other.wakeable_and_arg_;
   }
 
-  std::string ActivityDebugTag() {
-    return wakeable_ == nullptr ? "<unknown>" : wakeable_->ActivityDebugTag();
+  bool operator!=(const Waker& other) const noexcept {
+    return !operator==(other);
   }
 
- private:
-  friend class AtomicWaker;
-
-  Wakeable* Take() {
-    return std::exchange(wakeable_, promise_detail::unwakeable());
-  }
-
-  Wakeable* wakeable_;
-};
-
-// An atomic variant of Waker - this type is non-copyable and non-movable.
-class AtomicWaker {
- public:
-  explicit AtomicWaker(Wakeable* wakeable) : wakeable_(wakeable) {}
-  AtomicWaker() : AtomicWaker(promise_detail::unwakeable()) {}
-  explicit AtomicWaker(Waker waker) : AtomicWaker(waker.Take()) {}
-  ~AtomicWaker() { wakeable_.load(std::memory_order_acquire)->Drop(); }
-  AtomicWaker(const AtomicWaker&) = delete;
-  AtomicWaker& operator=(const AtomicWaker&) = delete;
-  AtomicWaker(AtomicWaker&& other) noexcept = delete;
-  AtomicWaker& operator=(AtomicWaker&& other) noexcept = delete;
-
-  // Wake the underlying activity.
-  void Wakeup() { Take()->Wakeup(); }
-
-  // Return true if there is a not-unwakeable wakeable present.
-  bool Armed() const noexcept {
-    return wakeable_.load(std::memory_order_relaxed) !=
-           promise_detail::unwakeable();
+  std::string ActivityDebugTag() {
+    return wakeable_and_arg_.ActivityDebugTag();
   }
 
-  // Set to some new waker
-  void Set(Waker waker) {
-    wakeable_.exchange(waker.Take(), std::memory_order_acq_rel)->Wakeup();
+  // This is for tests to assert that a waker is occupied or not.
+  bool is_unwakeable() const {
+    return wakeable_and_arg_.wakeable == promise_detail::unwakeable();
   }
 
  private:
-  Wakeable* Take() {
-    return wakeable_.exchange(promise_detail::unwakeable(),
-                              std::memory_order_acq_rel);
+  struct WakeableAndArg {
+    Wakeable* wakeable;
+    void* arg;
+
+    void Wakeup() { wakeable->Wakeup(arg); }
+    void Drop() { wakeable->Drop(arg); }
+    std::string ActivityDebugTag() const {
+      return wakeable == nullptr ? "<unknown>"
+                                 : wakeable->ActivityDebugTag(arg);
+    }
+    bool operator==(const WakeableAndArg& other) const noexcept {
+      return wakeable == other.wakeable && arg == other.arg;
+    }
+  };
+
+  WakeableAndArg Take() {
+    return std::exchange(wakeable_and_arg_,
+                         {promise_detail::unwakeable(), nullptr});
   }
 
-  std::atomic<Wakeable*> wakeable_;
+  WakeableAndArg wakeable_and_arg_;
 };
 
 // An Activity tracks execution of a single promise.
@@ -298,7 +284,7 @@ class FreestandingActivity : public Activity, private Wakeable {
  public:
   Waker MakeOwningWaker() final {
     Ref();
-    return Waker(this);
+    return Waker(this, nullptr);
   }
   Waker MakeNonOwningWaker() final;
 
@@ -347,7 +333,7 @@ class FreestandingActivity : public Activity, private Wakeable {
 
   Mutex* mu() ABSL_LOCK_RETURNED(mu_) { return &mu_; }
 
-  std::string ActivityDebugTag() const override { return DebugTag(); }
+  std::string ActivityDebugTag(void*) const override { return DebugTag(); }
 
  private:
   class Handle;
@@ -481,7 +467,7 @@ class PromiseActivity final
   // the activity to an external threadpool to run. If the activity is already
   // running on this thread, a note is taken of such and the activity is
   // repolled if it doesn't complete.
-  void Wakeup() final {
+  void Wakeup(void*) final {
     // If there is an active activity, but hey it's us, flag that and we'll loop
     // in RunLoop (that's calling from above here!).
     if (Activity::is_current()) {
@@ -500,12 +486,12 @@ class PromiseActivity final
   }
 
   // Drop a wakeup
-  void Drop() final { this->WakeupComplete(); }
+  void Drop(void*) final { this->WakeupComplete(); }
 
   // Notification that we're no longer executing - it's ok to destruct the
   // promise.
   void MarkDone() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
-    GPR_ASSERT(!absl::exchange(done_, true));
+    GPR_ASSERT(!std::exchange(done_, true));
     ScopedContext contexts(this);
     Destruct(&promise_holder_.promise);
   }
@@ -555,7 +541,7 @@ class PromiseActivity final
       // Run the promise.
       GPR_ASSERT(!done_);
       auto r = promise_holder_.promise();
-      if (auto* status = absl::get_if<kPollReadyIdx>(&r)) {
+      if (auto* status = r.value_if_ready()) {
         // If complete, destroy the promise, flag done, and exit this loop.
         MarkDone();
         return IntoStatus(status);
@@ -609,4 +595,4 @@ ActivityPtr MakeActivity(Factory promise_factory,
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_ACTIVITY_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_ACTIVITY_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_ARENA_PROMISE_H
-#define GRPC_CORE_LIB_PROMISE_ARENA_PROMISE_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_ARENA_PROMISE_H
+#define GRPC_SRC_CORE_LIB_PROMISE_ARENA_PROMISE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -228,4 +228,4 @@ class ArenaPromise {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_ARENA_PROMISE_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_ARENA_PROMISE_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_CONTEXT_H
-#define GRPC_CORE_LIB_PROMISE_CONTEXT_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_CONTEXT_H
+#define GRPC_SRC_CORE_LIB_PROMISE_CONTEXT_H
 
 #include <grpc/support/port_platform.h>
 
@@ -90,4 +90,4 @@ promise_detail::WithContext<T, F> WithContext(F f, T* context) {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_CONTEXT_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_CONTEXT_H

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

@@ -0,0 +1,197 @@
+// 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_DETAIL_BASIC_JOIN_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_JOIN_H
+
+#include <grpc/support/port_platform.h>
+
+#include <assert.h>
+#include <stddef.h>
+
+#include <array>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/utility/utility.h"
+
+#include "src/core/lib/gprpp/bitset.h"
+#include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+namespace promise_detail {
+
+// This union can either be a functor, or the result of the functor (after
+// mapping via a trait). Allows us to remember the result of one joined functor
+// until the rest are ready.
+template <typename Traits, typename F>
+union Fused {
+  explicit Fused(F&& f) : f(std::forward<F>(f)) {}
+  explicit Fused(PromiseLike<F>&& f) : f(std::forward<PromiseLike<F>>(f)) {}
+  ~Fused() {}
+  // Wrap the functor in a PromiseLike to handle immediately returning functors
+  // and the like.
+  using Promise = PromiseLike<F>;
+  GPR_NO_UNIQUE_ADDRESS Promise f;
+  // Compute the result type: We take the result of the promise, and pass it via
+  // our traits, so that, for example, TryJoin and take a StatusOr<T> and just
+  // store a T.
+  using Result = typename Traits::template ResultType<typename Promise::Result>;
+  GPR_NO_UNIQUE_ADDRESS Result result;
+};
+
+// A join gets composed of joints... these are just wrappers around a Fused for
+// their data, with some machinery as methods to get the system working.
+template <typename Traits, size_t kRemaining, typename... Fs>
+struct Joint : public Joint<Traits, kRemaining - 1, Fs...> {
+  // The index into Fs for this Joint
+  static constexpr size_t kIdx = sizeof...(Fs) - kRemaining;
+  // The next join (the one we derive from)
+  using NextJoint = Joint<Traits, kRemaining - 1, Fs...>;
+  // From Fs, extract the functor for this joint.
+  using F = typename std::tuple_element<kIdx, std::tuple<Fs...>>::type;
+  // Generate the Fused type for this functor.
+  using Fsd = Fused<Traits, F>;
+  GPR_NO_UNIQUE_ADDRESS Fsd fused;
+  // Figure out what kind of bitmask will be used by the outer join.
+  using Bits = BitSet<sizeof...(Fs)>;
+  // Initialize from a tuple of pointers to Fs
+  explicit Joint(std::tuple<Fs*...> fs)
+      : NextJoint(fs), fused(std::move(*std::get<kIdx>(fs))) {}
+  // Copy: assume that the Fuse is still in the promise state (since it's not
+  // legal to copy after the first poll!)
+  Joint(const Joint& j) : NextJoint(j), fused(j.fused.f) {}
+  // Move: assume that the Fuse is still in the promise state (since it's not
+  // legal to move after the first poll!)
+  Joint(Joint&& j) noexcept
+      : NextJoint(std::forward<NextJoint>(j)), fused(std::move(j.fused.f)) {}
+  // Destruct: check bits to see if we're in promise or result state, and call
+  // the appropriate destructor. Recursively, call up through the join.
+  void DestructAll(const Bits& bits) {
+    if (!bits.is_set(kIdx)) {
+      Destruct(&fused.f);
+    } else {
+      Destruct(&fused.result);
+    }
+    NextJoint::DestructAll(bits);
+  }
+  // Poll all joints up, and then call finally.
+  template <typename F>
+  auto Run(Bits* bits, F finally) -> decltype(finally()) {
+    // If we're still in the promise state...
+    if (!bits->is_set(kIdx)) {
+      // Poll the promise
+      auto r = fused.f();
+      if (auto* p = r.value_if_ready()) {
+        // If it's done, then ask the trait to unwrap it and store that result
+        // in the Fused, and continue the iteration. Note that OnResult could
+        // instead choose to return a value instead of recursing through the
+        // iteration, in that case we continue returning the same result up.
+        // Here is where TryJoin can escape out.
+        return Traits::OnResult(
+            std::move(*p), [this, bits, &finally](typename Fsd::Result result) {
+              bits->set(kIdx);
+              Destruct(&fused.f);
+              Construct(&fused.result, std::move(result));
+              return NextJoint::Run(bits, std::move(finally));
+            });
+      }
+    }
+    // That joint is still pending... we'll still poll the result of the joints.
+    return NextJoint::Run(bits, std::move(finally));
+  }
+};
+
+// Terminating joint... for each of the recursions, do the thing we're supposed
+// to do at the end.
+template <typename Traits, typename... Fs>
+struct Joint<Traits, 0, Fs...> {
+  explicit Joint(std::tuple<Fs*...>) {}
+  Joint(const Joint&) {}
+  Joint(Joint&&) noexcept {}
+  template <typename T>
+  void DestructAll(const T&) {}
+  template <typename F>
+  auto Run(BitSet<sizeof...(Fs)>*, F finally) -> decltype(finally()) {
+    return finally();
+  }
+};
+
+template <typename Traits, typename... Fs>
+class BasicJoin {
+ private:
+  // How many things are we joining?
+  static constexpr size_t N = sizeof...(Fs);
+  // Bitset: if a bit is 0, that joint is still in promise state. If it's 1,
+  // then the joint has a result.
+  GPR_NO_UNIQUE_ADDRESS BitSet<N> state_;
+  // The actual joints, wrapped in an anonymous union to give us control of
+  // construction/destruction.
+  union {
+    GPR_NO_UNIQUE_ADDRESS Joint<Traits, sizeof...(Fs), Fs...> joints_;
+  };
+
+  // Access joint index I
+  template <size_t I>
+  Joint<Traits, sizeof...(Fs) - I, Fs...>* GetJoint() {
+    return static_cast<Joint<Traits, sizeof...(Fs) - I, Fs...>*>(&joints_);
+  }
+
+  // The tuple of results of all our promises
+  using Tuple = std::tuple<typename Fused<Traits, Fs>::Result...>;
+
+  // Collect up all the results and construct a tuple.
+  template <size_t... I>
+  Tuple Finish(absl::index_sequence<I...>) {
+    return Tuple(std::move(GetJoint<I>()->fused.result)...);
+  }
+
+ public:
+  explicit BasicJoin(Fs&&... fs) : joints_(std::tuple<Fs*...>(&fs...)) {}
+  BasicJoin& operator=(const BasicJoin&) = delete;
+  // Copy a join - only available before polling.
+  BasicJoin(const BasicJoin& other) {
+    assert(other.state_.none());
+    Construct(&joints_, other.joints_);
+  }
+  // Move a join - only available before polling.
+  BasicJoin(BasicJoin&& other) noexcept {
+    assert(other.state_.none());
+    Construct(&joints_, std::move(other.joints_));
+  }
+  ~BasicJoin() { joints_.DestructAll(state_); }
+  using Result = decltype(Traits::Wrap(std::declval<Tuple>()));
+  // Poll the join
+  Poll<Result> operator()() {
+    // Poll the joints...
+    return joints_.Run(&state_, [this]() -> Poll<Result> {
+      // If all of them are completed, collect the results, and then ask our
+      // traits to wrap them - allowing for example TryJoin to turn tuple<A,B,C>
+      // into StatusOr<tuple<A,B,C>>.
+      if (state_.all()) {
+        return Traits::Wrap(Finish(absl::make_index_sequence<N>()));
+      } else {
+        return Pending();
+      }
+    });
+  }
+};
+
+}  // namespace promise_detail
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_JOIN_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
-#define GRPC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
 
 #include <grpc/support/port_platform.h>
 
@@ -24,7 +24,6 @@
 #include <utility>
 
 #include "absl/meta/type_traits.h"
-#include "absl/types/variant.h"
 #include "absl/utility/utility.h"
 
 #include "src/core/lib/gprpp/construct_destruct.h"
@@ -276,18 +275,15 @@ class BasicSeq {
     // Poll the current promise in this state.
     auto r = s->current_promise();
     // If we are still pending, say so by returning.
-    if (absl::holds_alternative<Pending>(r)) {
-      return Pending();
-    }
+    if (r.pending()) return Pending();
     // Current promise is ready, as the traits to do the next thing.
     // That may be returning - eg if TrySeq sees an error.
     // Or it may be by calling the callable we hand down - RunNext - which
     // will advance the state and call the next promise.
     return Traits<
         typename absl::remove_reference_t<decltype(*s)>::Types::PromiseResult>::
-        template CheckResultAndRunNext<Result>(
-            std::move(absl::get<kPollReadyIdx>(std::move(r))),
-            RunNext<I>{this});
+        template CheckResultAndRunNext<Result>(std::move(r.value()),
+                                               RunNext<I>{this});
   }
 
   // Specialization of RunState to run the final state.
@@ -296,11 +292,9 @@ class BasicSeq {
     // Poll the final promise.
     auto r = final_promise_();
     // If we are still pending, say so by returning.
-    if (absl::holds_alternative<Pending>(r)) {
-      return Pending();
-    }
+    if (r.pending()) return Pending();
     // We are complete, return the (wrapped) result.
-    return Result(std::move(absl::get<kPollReadyIdx>(std::move(r))));
+    return Result(std::move(r.value()));
   }
 
   // For state numbered I, destruct the current promise and the next promise
@@ -466,9 +460,9 @@ class BasicSeqIter {
  private:
   Poll<Wrapped> PollNonEmpty() {
     Poll<Wrapped> r = state_();
-    if (absl::holds_alternative<Pending>(r)) return r;
+    if (r.pending()) return r;
     return Traits::template CheckResultAndRunNext<Wrapped>(
-        std::move(absl::get<Wrapped>(r)), [this](Wrapped arg) -> Poll<Wrapped> {
+        std::move(r.value()), [this](Wrapped arg) -> Poll<Wrapped> {
           auto next = cur_;
           ++next;
           if (next == end_) {
@@ -494,4 +488,4 @@ class BasicSeqIter {
 }  // namespace promise_detail
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_BASIC_SEQ_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H
-#define GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -233,4 +233,4 @@ class RepeatedPromiseFactory<void, F> {
 }  // namespace promise_detail
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_FACTORY_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H
-#define GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -82,4 +82,4 @@ using RemoveCVRef = absl::remove_cv_t<absl::remove_reference_t<T>>;
 }  // namespace promise_detail
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_PROMISE_LIKE_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_DETAIL_STATUS_H
-#define GRPC_CORE_LIB_PROMISE_DETAIL_STATUS_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_STATUS_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_STATUS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -75,4 +75,4 @@ To StatusCast(From&& from) {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_DETAIL_STATUS_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_STATUS_H

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

@@ -18,8 +18,8 @@
 // Automatically generated by tools/codegen/core/gen_switch.py
 //
 
-#ifndef GRPC_CORE_LIB_PROMISE_DETAIL_SWITCH_H
-#define GRPC_CORE_LIB_PROMISE_DETAIL_SWITCH_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_SWITCH_H
+#define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_SWITCH_H
 
 #include <grpc/support/port_platform.h>
 
@@ -1452,4 +1452,4 @@ R Switch(char idx, F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7,
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_DETAIL_SWITCH_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_SWITCH_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H
-#define GRPC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H
+#define GRPC_SRC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -53,4 +53,4 @@ class ExecCtxWakeupScheduler {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H