grpc 1.51.0 → 1.52.0

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

@@ -387,23 +387,32 @@ class FreestandingActivity : public Activity, private Wakeable {
 };
 
 // Implementation details for an Activity of an arbitrary type of promise.
-// There should exist a static function:
+// There should exist an inner template class `BoundScheduler` that provides
+// the following interface:
 // struct WakeupScheduler {
 //   template <typename ActivityType>
-//   void ScheduleWakeup(ActivityType* activity);
+//   class BoundScheduler {
+//    public:
+//     BoundScheduler(WakeupScheduler);
+//     void ScheduleWakeup();
+//   };
 // };
-// This function should arrange that activity->RunScheduledWakeup() be invoked
-// at the earliest opportunity.
+// The ScheduleWakeup function should arrange that
+// static_cast<ActivityType*>(this)->RunScheduledWakeup() be invoked at the
+// earliest opportunity.
 // It can assume that activity will remain live until RunScheduledWakeup() is
 // invoked, and that a given activity will not be concurrently scheduled again
 // until its RunScheduledWakeup() has been invoked.
-// We use private inheritance here as a way of getting private members for
-// each of the contexts.
+// We use private inheritance here as a way of getting private members for each
+// of the contexts.
 // TODO(ctiller): We can probably reconsider the private inheritance here
 // when we move away from C++11 and have more powerful template features.
 template <class F, class WakeupScheduler, class OnDone, typename... Contexts>
-class PromiseActivity final : public FreestandingActivity,
-                              private ActivityContexts<Contexts...> {
+class PromiseActivity final
+    : public FreestandingActivity,
+      public WakeupScheduler::template BoundScheduler<
+          PromiseActivity<F, WakeupScheduler, OnDone, Contexts...>>,
+      private ActivityContexts<Contexts...> {
  public:
   using Factory = OncePromiseFactory<void, F>;
   using ResultType = typename Factory::Promise::Result;
@@ -411,8 +420,9 @@ class PromiseActivity final : public FreestandingActivity,
   PromiseActivity(F promise_factory, WakeupScheduler wakeup_scheduler,
                   OnDone on_done, Contexts&&... contexts)
       : FreestandingActivity(),
+        WakeupScheduler::template BoundScheduler<PromiseActivity>(
+            std::move(wakeup_scheduler)),
         ActivityContexts<Contexts...>(std::forward<Contexts>(contexts)...),
-        wakeup_scheduler_(std::move(wakeup_scheduler)),
         on_done_(std::move(on_done)) {
     // Lock, construct an initial promise from the factory, and step it.
     // This may hit a waiter, which could expose our this pointer to other
@@ -482,7 +492,7 @@ class PromiseActivity final : public FreestandingActivity,
     }
     if (!wakeup_scheduled_.exchange(true, std::memory_order_acq_rel)) {
       // Can't safely run, so ask to run later.
-      wakeup_scheduler_.ScheduleWakeup(this);
+      this->ScheduleWakeup();
     } else {
       // Already a wakeup scheduled for later, drop ref.
       WakeupComplete();
@@ -564,8 +574,6 @@ class PromiseActivity final : public FreestandingActivity,
   }
 
   using Promise = typename Factory::Promise;
-  // Scheduler for wakeups
-  GPR_NO_UNIQUE_ADDRESS WakeupScheduler wakeup_scheduler_;
   // Callback on completion of the promise.
   GPR_NO_UNIQUE_ADDRESS OnDone on_done_;
   // Has execution completed?

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

@@ -20,6 +20,7 @@
 #include <stdlib.h>
 
 #include <memory>
+#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
@@ -227,4 +228,4 @@ class ArenaPromise {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_PROMISE_ARENA_PROMISE_H */
+#endif  // GRPC_CORE_LIB_PROMISE_ARENA_PROMISE_H

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

@@ -17,6 +17,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <type_traits>
 #include <utility>
 
 #include <grpc/support/log.h>

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

@@ -17,6 +17,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"

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

@@ -1,22 +1,22 @@
-/*
- * 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.
- */
+//
+// 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.
+//
 
-/*
- * Automatically generated by tools/codegen/core/gen_switch.py
- */
+//
+// 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

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

@@ -31,18 +31,24 @@ namespace grpc_core {
 class ExecCtxWakeupScheduler {
  public:
   template <typename ActivityType>
-  void ScheduleWakeup(ActivityType* activity) {
-    GRPC_CLOSURE_INIT(
-        &closure_,
-        [](void* arg, grpc_error_handle) {
-          static_cast<ActivityType*>(arg)->RunScheduledWakeup();
-        },
-        activity, grpc_schedule_on_exec_ctx);
-    ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
-  }
-
- private:
-  grpc_closure closure_;
+  class BoundScheduler {
+   protected:
+    explicit BoundScheduler(ExecCtxWakeupScheduler) {}
+    BoundScheduler(const BoundScheduler&) = delete;
+    BoundScheduler& operator=(const BoundScheduler&) = delete;
+    void ScheduleWakeup() {
+      GRPC_CLOSURE_INIT(
+          &closure_,
+          [](void* arg, grpc_error_handle) {
+            static_cast<ActivityType*>(arg)->RunScheduledWakeup();
+          },
+          static_cast<ActivityType*>(this), nullptr);
+      ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
+    }
+
+   private:
+    grpc_closure closure_;
+  };
 };
 
 }  // namespace grpc_core

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

@@ -17,11 +17,15 @@
 
 #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"
 
@@ -55,20 +59,39 @@ class ForEach {
   using Result =
       typename PollTraits<decltype(std::declval<ActionPromise>()())>::Type;
   ForEach(Reader reader, Action action)
-      : reader_(std::move(reader)),
-        action_factory_(std::move(action)),
-        state_(reader_.Next()) {}
+      : 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;
-  // noexcept causes compiler errors on older gcc's
-  // NOLINTNEXTLINE(performance-noexcept-move-constructor)
-  ForEach(ForEach&&) = default;
-  // noexcept causes compiler errors on older gcc's
-  // NOLINTNEXTLINE(performance-noexcept-move-constructor)
-  ForEach& operator=(ForEach&&) = default;
-
-  Poll<Result> operator()() { return absl::visit(CallPoll{this}, state_); }
+  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 {
@@ -77,41 +100,44 @@ class ForEach {
     ActionPromise promise;
     ReaderResult result;
   };
-  Reader reader_;
-  ActionFactory action_factory_;
-  absl::variant<ReaderNext, InAction> state_;
-
-  // Call the inner poll function, and if it's finished, start the next
-  // iteration.
-  struct CallPoll {
-    ForEach* const self;
-
-    Poll<Result> operator()(ReaderNext& reader_next) {
-      auto r = reader_next();
-      if (auto* p = absl::get_if<kPollReadyIdx>(&r)) {
-        if (p->has_value()) {
-          auto action = self->action_factory_.Make(std::move(**p));
-          return (*this)(self->state_.template emplace<InAction>(
-              std::move(action), std::move(*p)));
-        } else {
-          return Done<Result>::Make();
-        }
+
+  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> operator()(InAction& in_action) {
-      auto r = in_action.promise();
-      if (auto* p = absl::get_if<kPollReadyIdx>(&r)) {
-        if (p->ok()) {
-          return (*this)(
-              self->state_.template emplace<ReaderNext>(self->reader_.Next()));
-        } else {
-          return std::move(*p);
-        }
+    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();
     }
+    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_;
   };
 };
 

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

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <type_traits>
+
 #include <grpc/support/log.h>
 
 #include "src/core/lib/promise/intra_activity_waiter.h"
@@ -31,23 +33,6 @@ namespace grpc_core {
 template <typename T>
 class Latch {
  public:
-  // This is the type of the promise returned by Wait.
-  class WaitPromise {
-   public:
-    Poll<T*> operator()() const {
-      if (latch_->has_value_) {
-        return &latch_->value_;
-      } else {
-        return latch_->waiter_.pending();
-      }
-    }
-
-   private:
-    friend class Latch;
-    explicit WaitPromise(Latch* latch) : latch_(latch) {}
-    Latch* latch_;
-  };
-
   Latch() = default;
   Latch(const Latch&) = delete;
   Latch& operator=(const Latch&) = delete;
@@ -67,11 +52,17 @@ class Latch {
   }
 
   // Produce a promise to wait for a value from this latch.
-  WaitPromise Wait() {
+  auto Wait() {
 #ifndef NDEBUG
     has_had_waiters_ = true;
 #endif
-    return WaitPromise(this);
+    return [this]() -> Poll<T*> {
+      if (has_value_) {
+        return &value_;
+      } else {
+        return waiter_.pending();
+      }
+    };
   }
 
   // Set the value of the latch. Can only be called once.
@@ -98,6 +89,9 @@ class Latch {
   IntraActivityWaiter waiter_;
 };
 
+template <typename T>
+using LatchWaitPromise = decltype(std::declval<Latch<T>>().Wait());
+
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_LIB_PROMISE_LATCH_H

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

@@ -20,6 +20,7 @@
 #include <stddef.h>
 
 #include <tuple>
+#include <type_traits>
 #include <utility>
 
 #include "absl/types/variant.h"

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

@@ -23,6 +23,7 @@
 #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 {
 

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

@@ -32,6 +32,12 @@ struct Pending {
   constexpr bool operator==(Pending) const { return true; }
 };
 
+// A type that contains no value. Useful for simulating 'void' in promises that
+// always need to return some kind of value.
+struct Empty {
+  constexpr bool operator==(Empty) const { return true; }
+};
+
 // The result of polling a Promise once.
 //
 // Can be either pending - the Promise has not yet completed, or ready -

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

@@ -17,6 +17,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <type_traits>
 #include <utility>
 
 #include "src/core/lib/promise/detail/basic_seq.h"

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

@@ -20,6 +20,7 @@
 #include <stddef.h>
 
 #include <cstdint>
+#include <type_traits>
 #include <utility>
 
 #include "absl/types/variant.h"

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

@@ -17,6 +17,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"

data/src/core/lib/resolver/resolver.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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.
+//
+//
 
 #include <grpc/support/port_platform.h>
 

data/src/core/lib/resolver/server_address.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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.
+//
+//
 
 #include <grpc/support/port_platform.h>
 

data/src/core/lib/resolver/server_address.h

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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_RESOLVER_SERVER_ADDRESS_H
 #define GRPC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H
@@ -142,4 +142,4 @@ class ServerAddressWeightAttribute : public ServerAddress::AttributeInterface {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H */
+#endif  // GRPC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H

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

@@ -20,7 +20,7 @@
 #include <stddef.h>
 
 #include <grpc/event_engine/endpoint_config.h>
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
 
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/resource_quota/resource_quota.h"

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 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.
- *
- */
+//
+//
+// Copyright 2017 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.
+//
+//
 
 #include <grpc/support/port_platform.h>