grpc 1.42.0 → 1.43.1

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

@@ -0,0 +1,48 @@
+// 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_EXEC_CTX_WAKEUP_SCHEDULER_H
+#define GRPC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+namespace grpc_core {
+
+// A callback scheduler for activities that works by scheduling callbacks on the
+// exec ctx.
+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_, GRPC_ERROR_NONE);
+  }
+
+ private:
+  grpc_closure closure_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H

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

@@ -0,0 +1,108 @@
+// 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_LOOP_H
+#define GRPC_CORE_LIB_PROMISE_LOOP_H
+
+#include <grpc/support/port_platform.h>
+
+#include <new>
+#include <type_traits>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/detail/promise_factory.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+// Special type - signals to loop to take another iteration, instead of
+// finishing
+struct Continue {};
+
+// Result of polling a loop promise - either Continue looping, or return a value
+// T
+template <typename T>
+using LoopCtl = absl::variant<Continue, T>;
+
+namespace promise_detail {
+
+template <typename T>
+struct LoopTraits;
+
+template <typename T>
+struct LoopTraits<LoopCtl<T>> {
+  using Result = T;
+};
+
+template <typename F>
+class Loop {
+ private:
+  using Factory = promise_detail::PromiseFactory<void, F>;
+  using Promise = decltype(std::declval<Factory>().Repeated());
+  using PromiseResult = typename Promise::Result;
+
+ public:
+  using Result = typename LoopTraits<PromiseResult>::Result;
+
+  explicit Loop(F f) : factory_(std::move(f)), promise_(factory_.Repeated()) {}
+  ~Loop() { promise_.~Promise(); }
+
+  Loop(Loop&& loop) noexcept
+      : factory_(std::move(loop.factory_)),
+        promise_(std::move(loop.promise_)) {}
+
+  Loop(const Loop& loop) = delete;
+  Loop& operator=(const Loop& loop) = delete;
+
+  Poll<Result> operator()() {
+    while (true) {
+      // Poll the inner promise.
+      auto promise_result = promise_();
+      // If it returns a value:
+      if (auto* p = absl::get_if<kPollReadyIdx>(&promise_result)) {
+        //  - then if it's Continue, destroy the promise and recreate a new one
+        //  from our factory.
+        if (absl::holds_alternative<Continue>(*p)) {
+          promise_.~Promise();
+          new (&promise_) Promise(factory_.Repeated());
+          continue;
+        }
+        //  - otherwise there's our result... return it out.
+        return absl::get<Result>(*p);
+      } else {
+        // Otherwise the inner promise was pending, so we are pending.
+        return Pending();
+      }
+    }
+  }
+
+ private:
+  GPR_NO_UNIQUE_ADDRESS Factory factory_;
+  GPR_NO_UNIQUE_ADDRESS union { GPR_NO_UNIQUE_ADDRESS Promise promise_; };
+};
+
+}  // namespace promise_detail
+
+// Looping combinator.
+// Expects F returns LoopCtl<T> - if it's Continue, then run the loop again -
+// otherwise yield the returned value as the result of the loop.
+template <typename F>
+promise_detail::Loop<F> Loop(F f) {
+  return promise_detail::Loop<F>(std::move(f));
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_LOOP_H

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

@@ -0,0 +1,88 @@
+// 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_MAP_H
+#define GRPC_CORE_LIB_PROMISE_MAP_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+// Implementation of mapping combinator - use this via the free function below!
+// Promise is the type of promise to poll on, Fn is a function that takes the
+// result of Promise and maps it to some new type.
+template <typename Promise, typename Fn>
+class Map {
+ public:
+  Map(Promise promise, Fn fn)
+      : promise_(std::move(promise)), fn_(std::move(fn)) {}
+
+  using PromiseResult = typename PromiseLike<Promise>::Result;
+  using Result =
+      RemoveCVRef<decltype(std::declval<Fn>()(std::declval<PromiseResult>()))>;
+
+  Poll<Result> operator()() {
+    Poll<PromiseResult> r = promise_();
+    if (auto* p = absl::get_if<kPollReadyIdx>(&r)) {
+      return fn_(std::move(*p));
+    }
+    return Pending();
+  }
+
+ private:
+  PromiseLike<Promise> promise_;
+  Fn fn_;
+};
+
+}  // namespace promise_detail
+
+// Mapping combinator.
+// Takes a promise, and a synchronous function to mutate its result, and
+// returns a promise.
+template <typename Promise, typename Fn>
+promise_detail::Map<Promise, Fn> Map(Promise promise, Fn fn) {
+  return promise_detail::Map<Promise, Fn>(std::move(promise), std::move(fn));
+}
+
+// Callable that takes a tuple and returns one element
+template <size_t kElem>
+struct JustElem {
+  template <typename... A>
+  auto operator()(std::tuple<A...>&& t) const
+      -> decltype(std::get<kElem>(std::forward<std::tuple<A...>>(t))) {
+    return std::get<kElem>(std::forward<std::tuple<A...>>(t));
+  }
+  template <typename... A>
+  auto operator()(const std::tuple<A...>& t) const
+      -> decltype(std::get<kElem>(t)) {
+    return std::get<kElem>(t);
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_MAP_H

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

@@ -0,0 +1,60 @@
+// 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_POLL_H
+#define GRPC_CORE_LIB_PROMISE_POLL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "absl/types/variant.h"
+
+namespace grpc_core {
+
+// A type that signals a Promise is still pending and not yet completed.
+// Allows writing 'return Pending{}' and with automatic conversions gets
+// upgraded to a Poll<> object.
+struct Pending {
+  constexpr bool operator==(Pending) const { return true; }
+};
+
+// The result of polling a Promise once.
+//
+// Can be either pending - the Promise has not yet completed, or ready -
+// indicating that the Promise has completed AND should not be polled again.
+template <typename T>
+using Poll = absl::variant<Pending, T>;
+
+// Variant of Poll that serves as a ready value
+static constexpr size_t kPollReadyIdx = 1;
+
+// PollTraits tells us whether a type is Poll<> or some other type, and is
+// leveraged in the PromiseLike/PromiseFactory machinery to select the
+// appropriate implementation of those concepts based upon the return type of a
+// lambda, for example (via enable_if).
+template <typename T>
+struct PollTraits {
+  static constexpr bool is_poll() { return false; }
+};
+
+template <typename T>
+struct PollTraits<Poll<T>> {
+  using Type = T;
+  static constexpr bool is_poll() { return true; }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_POLL_H

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

@@ -0,0 +1,84 @@
+// 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_RACE_H
+#define GRPC_CORE_LIB_PROMISE_RACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <tuple>
+#include <type_traits>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+// Implementation type for Race combinator.
+template <typename... Promises>
+class Race;
+
+template <typename Promise, typename... Promises>
+class Race<Promise, Promises...> {
+ public:
+  using Result = decltype(std::declval<Promise>()());
+
+  explicit Race(Promise promise, Promises... promises)
+      : promise_(std::move(promise)), next_(std::move(promises)...) {}
+
+  Result operator()() {
+    // Check our own promise.
+    auto r = promise_();
+    if (absl::holds_alternative<Pending>(r)) {
+      // Check the rest of them.
+      return next_();
+    }
+    // Return the first ready result.
+    return std::move(absl::get<kPollReadyIdx>(std::move(r)));
+  }
+
+ private:
+  // The Promise checked by this instance.
+  Promise promise_;
+  // We recursively expand to check the rest of the instances.
+  Race<Promises...> next_;
+};
+
+template <typename Promise>
+class Race<Promise> {
+ public:
+  using Result = decltype(std::declval<Promise>()());
+  explicit Race(Promise promise) : promise_(std::move(promise)) {}
+  Result operator()() { return promise_(); }
+
+ private:
+  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>
+promise_detail::Race<Promises...> Race(Promises... promises) {
+  return promise_detail::Race<Promises...>(std::move(promises)...);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_RACE_H

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

@@ -0,0 +1,71 @@
+// 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_SEQ_H
+#define GRPC_CORE_LIB_PROMISE_SEQ_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+template <typename T>
+struct SeqTraits {
+  using UnwrappedType = T;
+  using WrappedType = T;
+  template <typename Next>
+  static auto CallFactory(Next* next, T&& value)
+      -> decltype(next->Once(std::forward<T>(value))) {
+    return next->Once(std::forward<T>(value));
+  }
+
+  template <typename Result, typename PriorResult, typename RunNext>
+  static Poll<Result> CheckResultAndRunNext(PriorResult prior,
+                                            RunNext run_next) {
+    return run_next(std::move(prior));
+  }
+};
+
+template <typename... Fs>
+using Seq = BasicSeq<SeqTraits, Fs...>;
+
+}  // 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... Functors>
+promise_detail::Seq<Functors...> Seq(Functors... functors) {
+  return promise_detail::Seq<Functors...>(std::move(functors)...);
+}
+
+template <typename F>
+F Seq(F functor) {
+  return functor;
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_SEQ_H

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

@@ -0,0 +1,108 @@
+// 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.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/resource_quota/api.h"
+
+#include <grpc/grpc.h>
+
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+namespace grpc_core {
+
+ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(
+    const grpc_channel_args* args) {
+  return grpc_channel_args_find_pointer<ResourceQuota>(args,
+                                                       GRPC_ARG_RESOURCE_QUOTA)
+      ->Ref();
+}
+
+namespace {
+grpc_arg MakeArg(ResourceQuota* quota) {
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(GRPC_ARG_RESOURCE_QUOTA), quota,
+      grpc_resource_quota_arg_vtable());
+}
+
+const grpc_channel_args* EnsureResourceQuotaInChannelArgs(
+    const grpc_channel_args* args) {
+  const grpc_arg* existing =
+      grpc_channel_args_find(args, GRPC_ARG_RESOURCE_QUOTA);
+  if (existing != nullptr && existing->type == GRPC_ARG_POINTER &&
+      existing->value.pointer.p != nullptr) {
+    return grpc_channel_args_copy(args);
+  }
+  // If there's no existing quota, add it to the default one - shared between
+  // all channel args declared thusly. This prevents us from accidentally not
+  // sharing subchannels due to their channel args not specifying a quota.
+  const char* remove[] = {GRPC_ARG_RESOURCE_QUOTA};
+  auto new_arg = MakeArg(ResourceQuota::Default().get());
+  return grpc_channel_args_copy_and_add_and_remove(args, remove, 1, &new_arg,
+                                                   1);
+}
+}  // namespace
+
+void RegisterResourceQuota(CoreConfiguration::Builder* builder) {
+  builder->channel_args_preconditioning()->RegisterStage(
+      EnsureResourceQuotaInChannelArgs);
+}
+
+}  // namespace grpc_core
+
+extern "C" const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable() {
+  static const grpc_arg_pointer_vtable vtable = {
+      // copy
+      [](void* p) -> void* {
+        return static_cast<grpc_core::ResourceQuota*>(p)->Ref().release();
+      },
+      // destroy
+      [](void* p) { static_cast<grpc_core::ResourceQuota*>(p)->Unref(); },
+      // compare
+      [](void* p, void* q) { return grpc_core::QsortCompare(p, q); }};
+  return &vtable;
+}
+
+extern "C" grpc_resource_quota* grpc_resource_quota_create(const char* name) {
+  static std::atomic<uintptr_t> anonymous_counter{0};
+  std::string quota_name =
+      name == nullptr
+          ? absl::StrCat("anonymous-quota-", anonymous_counter.fetch_add(1))
+          : name;
+  return (new grpc_core::ResourceQuota(std::move(quota_name)))->c_ptr();
+}
+
+extern "C" void grpc_resource_quota_ref(grpc_resource_quota* resource_quota) {
+  grpc_core::ResourceQuota::FromC(resource_quota)->Ref().release();
+}
+
+extern "C" void grpc_resource_quota_unref(grpc_resource_quota* resource_quota) {
+  grpc_core::ResourceQuota::FromC(resource_quota)->Unref();
+}
+
+extern "C" void grpc_resource_quota_resize(grpc_resource_quota* resource_quota,
+                                           size_t new_size) {
+  grpc_core::ExecCtx exec_ctx;
+  grpc_core::ResourceQuota::FromC(resource_quota)
+      ->memory_quota()
+      ->SetSize(new_size);
+}
+
+extern "C" void grpc_resource_quota_set_max_threads(
+    grpc_resource_quota* resource_quota, int new_max_threads) {
+  grpc_core::ResourceQuota::FromC(resource_quota)
+      ->thread_quota()
+      ->SetMax(new_max_threads);
+}

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

@@ -0,0 +1,41 @@
+// 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_RESOURCE_QUOTA_API_H
+#define GRPC_CORE_LIB_RESOURCE_QUOTA_API_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
+
+typedef struct grpc_resource_quota grpc_resource_quota;
+
+namespace grpc_core {
+
+// TODO(ctiller): This is a hack. We need to do real accounting instead of
+// hard coding.
+constexpr size_t kResourceQuotaCallSize = 15 * 1024;
+constexpr size_t kResourceQuotaChannelSize = 50 * 1024;
+
+// Retrieve the resource quota from the channel args.
+// UB if not set.
+ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(const grpc_channel_args* args);
+
+void RegisterResourceQuota(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_RESOURCE_QUOTA_API_H