grpc 1.47.0 → 1.49.0.pre1

data/src/core/lib/event_engine/posix_engine/timer_manager.h

@@ -0,0 +1,120 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/forkable.h"
+#include "src/core/lib/event_engine/posix_engine/timer.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/thd.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+// Timer Manager tries to keep only one thread waiting for the next timeout at
+// all times, and thus effectively preventing the thundering herd problem.
+// TODO(ctiller): consider unifying this thread pool and the one in
+// thread_pool.{h,cc}.
+class TimerManager final : public grpc_event_engine::experimental::Forkable {
+ public:
+  TimerManager();
+  ~TimerManager() override;
+
+  grpc_core::Timestamp Now() { return host_.Now(); }
+
+  void TimerInit(Timer* timer, grpc_core::Timestamp deadline,
+                 experimental::EventEngine::Closure* closure);
+  bool TimerCancel(Timer* timer);
+
+  // Forkable
+  void PrepareFork() override;
+  void PostforkParent() override;
+  void PostforkChild() override;
+
+ private:
+  struct RunThreadArgs {
+    TimerManager* self;
+    grpc_core::Thread thread;
+  };
+
+  class Host final : public TimerListHost {
+   public:
+    explicit Host(TimerManager* timer_manager)
+        : timer_manager_(timer_manager) {}
+
+    void Kick() override;
+    grpc_core::Timestamp Now() override;
+
+   private:
+    TimerManager* const timer_manager_;
+  };
+
+  void StartThread() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  static void RunThread(void* arg);
+  void MainLoop();
+  void RunSomeTimers(std::vector<experimental::EventEngine::Closure*> timers);
+  bool WaitUntil(grpc_core::Timestamp next);
+  void Kick();
+
+  grpc_core::Mutex mu_;
+  grpc_core::CondVar cv_;
+  Host host_;
+  // number of threads in the system
+  size_t thread_count_ ABSL_GUARDED_BY(mu_) = 0;
+  // number of threads sitting around waiting
+  size_t waiter_count_ ABSL_GUARDED_BY(mu_) = 0;
+  // Threads waiting to be joined
+  std::vector<grpc_core::Thread> completed_threads_ ABSL_GUARDED_BY(mu_);
+  // is there a thread waiting until the next timer should fire?
+  bool has_timed_waiter_ ABSL_GUARDED_BY(mu_) = false;
+  // are we shutting down?
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
+  // are we forking?
+  bool forking_ ABSL_GUARDED_BY(mu_) = false;
+  // are we shutting down?
+  bool kicked_ ABSL_GUARDED_BY(mu_) = false;
+  // the deadline of the current timed waiter thread (only relevant if
+  // has_timed_waiter_ is true)
+  grpc_core::Timestamp timed_waiter_deadline_ ABSL_GUARDED_BY(mu_);
+  // generation counter to track which thread is waiting for the next timer
+  uint64_t timed_waiter_generation_ ABSL_GUARDED_BY(mu_) = 0;
+  // number of timer wakeups
+  uint64_t wakeups_ ABSL_GUARDED_BY(mu_) = 0;
+  // actual timer implementation
+  std::unique_ptr<TimerList> timer_list_;
+  int prefork_thread_count_ = 0;
+};
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine
+
+#endif /* GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H */

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

@@ -0,0 +1,78 @@
+// Copyright 2021 The 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_EVENT_ENGINE_PROMISE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_PROMISE_H
+#include <grpc/support/port_platform.h>
+
+#include "absl/time/time.h"
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// A minimal promise implementation.
+///
+/// This is light-duty, syntactical sugar around cv wait & signal, which is
+/// useful in some cases. A more robust implementation is being worked on
+/// separately.
+template <typename T>
+class Promise {
+ public:
+  Promise() = default;
+  // Initialize a default value that will be returned if WaitWithTimeout times
+  // out
+  explicit Promise(T&& val) : val_(val) {}
+  // The getter will wait until the setter has been called, and will return the
+  // value passed during Set.
+  T& Get() { return WaitWithTimeout(absl::Hours(1)); }
+  // The getter will wait with timeout until the setter has been called, and
+  // will return the value passed during Set.
+  T& WaitWithTimeout(absl::Duration d) {
+    grpc_core::MutexLock lock(&mu_);
+    if (!set_) {
+      cv_.WaitWithTimeout(&mu_, d);
+    }
+    return val_;
+  }
+  // This setter can only be called exactly once without a Reset.
+  // Will automatically unblock getters.
+  void Set(T&& val) {
+    grpc_core::MutexLock lock(&mu_);
+    GPR_ASSERT(!set_);
+    val_ = std::move(val);
+    set_ = true;
+    cv_.SignalAll();
+  }
+
+  // Can only be called after a set operation.
+  void Reset() {
+    grpc_core::MutexLock lock(&mu_);
+    GPR_ASSERT(set_);
+    set_ = false;
+  }
+
+ private:
+  grpc_core::Mutex mu_;
+  grpc_core::CondVar cv_;
+  T val_;
+  bool set_ = false;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_PROMISE_H

data/src/core/lib/event_engine/socket_notifier.h

@@ -0,0 +1,55 @@
+// 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_EVENT_ENGINE_SOCKET_NOTIFIER_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_SOCKET_NOTIFIER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/status/status.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Generically wraps a socket/fd, and manages the registration of callbacks and
+// triggering of notifications on it.
+class SocketNotifier {
+ public:
+  virtual ~SocketNotifier() = default;
+  // Schedule on_read to be invoked when the underlying socket
+  // becomes readable.
+  // If the socket is already readable, the callback will be executed as soon as
+  // possible.
+  virtual void NotifyOnRead(EventEngine::Closure* on_read) = 0;
+  // Schedule on_write to be invoked when the underlying socket
+  // becomes writable.
+  // If the socket is already writable, the callback will be executed as soon as
+  // possible.
+  virtual void NotifyOnWrite(EventEngine::Closure* on_write) = 0;
+  // Set a readable event on the underlying socket.
+  virtual void SetReadable() = 0;
+  // Set a writable event on the underlying socket.
+  virtual void SetWritable() = 0;
+  // Shutdown a SocketNotifier. After this operation, NotifyXXX and SetXXX
+  // operations cannot be performed.
+  virtual void MaybeShutdown(absl::Status why) = 0;
+  // Returns true if the SocketNotifier has been shutdown.
+  virtual bool IsShutdown() = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_SOCKET_NOTIFIER_H

data/src/core/lib/event_engine/thread_pool.cc

@@ -0,0 +1,158 @@
+/*
+ *
+ * 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>
+
+#include "src/core/lib/event_engine/thread_pool.h"
+
+#include <utility>
+
+#include "src/core/lib/gprpp/thd.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+ThreadPool::Thread::Thread(ThreadPool* pool)
+    : pool_(pool),
+      thd_(
+          "posix_eventengine_pool",
+          [](void* th) { static_cast<ThreadPool::Thread*>(th)->ThreadFunc(); },
+          this, nullptr, grpc_core::Thread::Options().set_tracked(false)) {
+  thd_.Start();
+}
+ThreadPool::Thread::~Thread() { thd_.Join(); }
+
+void ThreadPool::Thread::ThreadFunc() {
+  pool_->ThreadFunc();
+  // Now that we have killed ourselves, we should reduce the thread count
+  grpc_core::MutexLock lock(&pool_->mu_);
+  pool_->nthreads_--;
+  // Move ourselves to dead list
+  pool_->dead_threads_.push_back(this);
+
+  if (pool_->nthreads_ == 0) {
+    if (pool_->forking_) pool_->fork_cv_.Signal();
+    if (pool_->shutdown_) pool_->shutdown_cv_.Signal();
+  }
+}
+
+void ThreadPool::ThreadFunc() {
+  for (;;) {
+    // Wait until work is available or we are shutting down.
+    grpc_core::ReleasableMutexLock lock(&mu_);
+    if (!forking_ && !shutdown_ && callbacks_.empty()) {
+      // If there are too many threads waiting, then quit this thread
+      if (threads_waiting_ >= reserve_threads_) {
+        break;
+      }
+      threads_waiting_++;
+      cv_.Wait(&mu_);
+      threads_waiting_--;
+    }
+    // a fork could be initiated while the thread was waiting
+    if (forking_) return;
+    // Drain callbacks before considering shutdown to ensure all work
+    // gets completed.
+    if (!callbacks_.empty()) {
+      auto cb = std::move(callbacks_.front());
+      callbacks_.pop();
+      lock.Release();
+      cb();
+    } else if (shutdown_) {
+      break;
+    }
+  }
+}
+
+ThreadPool::ThreadPool(int reserve_threads)
+    : shutdown_(false),
+      reserve_threads_(reserve_threads),
+      nthreads_(0),
+      threads_waiting_(0),
+      forking_(false) {
+  grpc_core::MutexLock lock(&mu_);
+  StartNThreadsLocked(reserve_threads_);
+}
+
+void ThreadPool::StartNThreadsLocked(int n) {
+  for (int i = 0; i < n; i++) {
+    nthreads_++;
+    new Thread(this);
+  }
+}
+
+void ThreadPool::ReapThreads(std::vector<Thread*>* tlist) {
+  for (auto* t : *tlist) delete t;
+  tlist->clear();
+}
+
+ThreadPool::~ThreadPool() {
+  grpc_core::MutexLock lock(&mu_);
+  shutdown_ = true;
+  cv_.SignalAll();
+  while (nthreads_ != 0) {
+    shutdown_cv_.Wait(&mu_);
+  }
+  ReapThreads(&dead_threads_);
+}
+
+void ThreadPool::Add(absl::AnyInvocable<void()> callback) {
+  grpc_core::MutexLock lock(&mu_);
+  // Add works to the callbacks list
+  callbacks_.push(std::move(callback));
+  // Store the callback for later if we are forking.
+  // TODO(hork): should we block instead?
+  if (forking_) return;
+  // Increase pool size or notify as needed
+  if (threads_waiting_ == 0) {
+    // Kick off a new thread
+    nthreads_++;
+    new Thread(this);
+  } else {
+    cv_.Signal();
+  }
+  // Also use this chance to harvest dead threads
+  if (!dead_threads_.empty()) {
+    ReapThreads(&dead_threads_);
+  }
+}
+
+void ThreadPool::PrepareFork() {
+  grpc_core::MutexLock lock(&mu_);
+  forking_ = true;
+  cv_.SignalAll();
+  while (nthreads_ != 0) {
+    fork_cv_.Wait(&mu_);
+  }
+  ReapThreads(&dead_threads_);
+}
+
+void ThreadPool::PostforkParent() {
+  grpc_core::MutexLock lock(&mu_);
+  forking_ = false;
+  StartNThreadsLocked(reserve_threads_);
+}
+
+void ThreadPool::PostforkChild() {
+  grpc_core::MutexLock lock(&mu_);
+  forking_ = false;
+  StartNThreadsLocked(reserve_threads_);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/thread_pool.h

@@ -0,0 +1,81 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <queue>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
+
+#include "src/core/lib/event_engine/forkable.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/thd.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class ThreadPool final : public grpc_event_engine::experimental::Forkable {
+ public:
+  explicit ThreadPool(int reserve_threads);
+  ~ThreadPool() override;
+
+  void Add(absl::AnyInvocable<void()> callback);
+
+  // Forkable
+  void PrepareFork() override;
+  void PostforkParent() override;
+  void PostforkChild() override;
+
+ private:
+  class Thread {
+   public:
+    explicit Thread(ThreadPool* pool);
+    ~Thread();
+
+   private:
+    ThreadPool* pool_;
+    grpc_core::Thread thd_;
+    void ThreadFunc();
+  };
+
+  void ThreadFunc();
+  void StartNThreadsLocked(int n) ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
+  static void ReapThreads(std::vector<Thread*>* tlist);
+
+  grpc_core::Mutex mu_;
+  grpc_core::CondVar cv_;
+  grpc_core::CondVar shutdown_cv_;
+  grpc_core::CondVar fork_cv_;
+  bool shutdown_;
+  std::queue<absl::AnyInvocable<void()>> callbacks_;
+  int reserve_threads_;
+  int nthreads_;
+  int threads_waiting_;
+  std::vector<Thread*> dead_threads_;
+  bool forking_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H

data/src/core/lib/event_engine/utils.cc

@@ -0,0 +1,49 @@
+// 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.
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/event_engine/utils.h"
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <chrono>
+
+#include "absl/strings/str_cat.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+std::string HandleToString(EventEngine::TaskHandle handle) {
+  return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
+}
+
+grpc_core::Timestamp ToTimestamp(grpc_core::Timestamp now,
+                                 EventEngine::Duration delta) {
+  return now +
+         std::max(grpc_core::Duration::Milliseconds(1),
+                  grpc_core::Duration::NanosecondsRoundUp(delta.count())) +
+         grpc_core::Duration::Milliseconds(1);
+}
+
+size_t Milliseconds(EventEngine::Duration d) {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(d).count();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/utils.h

@@ -0,0 +1,40 @@
+// 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_EVENT_ENGINE_UTILS_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_UTILS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <string>
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+std::string HandleToString(EventEngine::TaskHandle handle);
+
+grpc_core::Timestamp ToTimestamp(grpc_core::Timestamp now,
+                                 EventEngine::Duration delta);
+
+size_t Milliseconds(EventEngine::Duration d);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_UTILS_H