grpc 1.55.3 → 1.56.0.pre3

data/src/core/lib/event_engine/{thread_pool.cc → thread_pool/original_thread_pool.cc}

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/event_engine/thread_pool.h"
+#include "src/core/lib/event_engine/thread_pool/original_thread_pool.h"
 
 #include <atomic>
 #include <memory>
@@ -37,7 +37,7 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-void ThreadPool::StartThread(StatePtr state, StartThreadReason reason) {
+void OriginalThreadPool::StartThread(StatePtr state, StartThreadReason reason) {
   state->thread_count.Add();
   const auto now = grpc_core::Timestamp::Now();
   switch (reason) {
@@ -95,13 +95,13 @@ void ThreadPool::StartThread(StatePtr state, StartThreadReason reason) {
       .Start();
 }
 
-void ThreadPool::ThreadFunc(StatePtr state) {
+void OriginalThreadPool::ThreadFunc(StatePtr state) {
   while (state->queue.Step()) {
   }
   state->thread_count.Remove();
 }
 
-bool ThreadPool::Queue::Step() {
+bool OriginalThreadPool::Queue::Step() {
   grpc_core::ReleasableMutexLock lock(&queue_mu_);
   // Wait until work is available or we are shutting down.
   while (!shutdown_ && !forking_ && callbacks_.empty()) {
@@ -130,17 +130,19 @@ bool ThreadPool::Queue::Step() {
   return true;
 }
 
-ThreadPool::ThreadPool() {
-  for (unsigned i = 0; i < reserve_threads_; i++) {
+OriginalThreadPool::OriginalThreadPool(size_t reserve_threads)
+    : reserve_threads_(reserve_threads),
+      state_(std::make_shared<State>(reserve_threads)) {
+  for (unsigned i = 0; i < reserve_threads; i++) {
     StartThread(state_, StartThreadReason::kInitialPool);
   }
 }
 
-bool ThreadPool::IsThreadPoolThread() {
+bool OriginalThreadPool::IsThreadPoolThread() {
   return ThreadLocal::IsEventEngineThread();
 }
 
-void ThreadPool::Quiesce() {
+void OriginalThreadPool::Quiesce() {
   state_->queue.SetShutdown(true);
   // Wait until all threads are exited.
   // Note that if this is a threadpool thread then we won't exit this thread
@@ -151,22 +153,22 @@ void ThreadPool::Quiesce() {
   quiesced_.store(true, std::memory_order_relaxed);
 }
 
-ThreadPool::~ThreadPool() {
+OriginalThreadPool::~OriginalThreadPool() {
   GPR_ASSERT(quiesced_.load(std::memory_order_relaxed));
 }
 
-void ThreadPool::Run(absl::AnyInvocable<void()> callback) {
+void OriginalThreadPool::Run(absl::AnyInvocable<void()> callback) {
   GPR_DEBUG_ASSERT(quiesced_.load(std::memory_order_relaxed) == false);
   if (state_->queue.Add(std::move(callback))) {
     StartThread(state_, StartThreadReason::kNoWaitersWhenScheduling);
   }
 }
 
-void ThreadPool::Run(EventEngine::Closure* closure) {
+void OriginalThreadPool::Run(EventEngine::Closure* closure) {
   Run([closure]() { closure->Run(); });
 }
 
-bool ThreadPool::Queue::Add(absl::AnyInvocable<void()> callback) {
+bool OriginalThreadPool::Queue::Add(absl::AnyInvocable<void()> callback) {
   grpc_core::MutexLock lock(&queue_mu_);
   // Add works to the callbacks list
   callbacks_.push(std::move(callback));
@@ -175,13 +177,13 @@ bool ThreadPool::Queue::Add(absl::AnyInvocable<void()> callback) {
   return callbacks_.size() > threads_waiting_;
 }
 
-bool ThreadPool::Queue::IsBacklogged() {
+bool OriginalThreadPool::Queue::IsBacklogged() {
   grpc_core::MutexLock lock(&queue_mu_);
   if (forking_) return false;
   return callbacks_.size() > 1;
 }
 
-void ThreadPool::Queue::SleepIfRunning() {
+void OriginalThreadPool::Queue::SleepIfRunning() {
   grpc_core::MutexLock lock(&queue_mu_);
   auto end = grpc_core::Duration::Seconds(1) + grpc_core::Timestamp::Now();
   while (true) {
@@ -191,33 +193,33 @@ void ThreadPool::Queue::SleepIfRunning() {
   }
 }
 
-void ThreadPool::Queue::SetShutdown(bool is_shutdown) {
+void OriginalThreadPool::Queue::SetShutdown(bool is_shutdown) {
   grpc_core::MutexLock lock(&queue_mu_);
   auto was_shutdown = std::exchange(shutdown_, is_shutdown);
   GPR_ASSERT(is_shutdown != was_shutdown);
   cv_.SignalAll();
 }
 
-void ThreadPool::Queue::SetForking(bool is_forking) {
+void OriginalThreadPool::Queue::SetForking(bool is_forking) {
   grpc_core::MutexLock lock(&queue_mu_);
   auto was_forking = std::exchange(forking_, is_forking);
   GPR_ASSERT(is_forking != was_forking);
   cv_.SignalAll();
 }
 
-void ThreadPool::ThreadCount::Add() {
+void OriginalThreadPool::ThreadCount::Add() {
   grpc_core::MutexLock lock(&thread_count_mu_);
   ++threads_;
 }
 
-void ThreadPool::ThreadCount::Remove() {
+void OriginalThreadPool::ThreadCount::Remove() {
   grpc_core::MutexLock lock(&thread_count_mu_);
   --threads_;
   cv_.Signal();
 }
 
-void ThreadPool::ThreadCount::BlockUntilThreadCount(int threads,
-                                                    const char* why) {
+void OriginalThreadPool::ThreadCount::BlockUntilThreadCount(int threads,
+                                                            const char* why) {
   grpc_core::MutexLock lock(&thread_count_mu_);
   auto last_log = absl::Now();
   while (threads_ > threads) {
@@ -227,22 +229,23 @@ void ThreadPool::ThreadCount::BlockUntilThreadCount(int threads,
     // fork.
     cv_.WaitWithTimeout(&thread_count_mu_, absl::Seconds(3));
     if (threads_ > threads && absl::Now() - last_log > absl::Seconds(1)) {
-      gpr_log(GPR_ERROR, "Waiting for thread pool to idle before %s", why);
+      gpr_log(GPR_ERROR, "Waiting for thread pool to idle before %s (%d to %d)",
+              why, threads_, threads);
       last_log = absl::Now();
     }
   }
 }
 
-void ThreadPool::PrepareFork() {
+void OriginalThreadPool::PrepareFork() {
   state_->queue.SetForking(true);
   state_->thread_count.BlockUntilThreadCount(0, "forking");
 }
 
-void ThreadPool::PostforkParent() { Postfork(); }
+void OriginalThreadPool::PostforkParent() { Postfork(); }
 
-void ThreadPool::PostforkChild() { Postfork(); }
+void OriginalThreadPool::PostforkChild() { Postfork(); }
 
-void ThreadPool::Postfork() {
+void OriginalThreadPool::Postfork() {
   state_->queue.SetForking(false);
   for (unsigned i = 0; i < reserve_threads_; i++) {
     StartThread(state_, StartThreadReason::kInitialPool);

data/src/core/lib/event_engine/{thread_pool.h → thread_pool/original_thread_pool.h}

@@ -15,12 +15,12 @@
 // limitations under the License.
 //
 //
-
-#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
-#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_ORIGINAL_THREAD_POOL_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_ORIGINAL_THREAD_POOL_H
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include <atomic>
@@ -31,23 +31,20 @@
 #include "absl/functional/any_invocable.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/support/cpu.h>
 
-#include "src/core/lib/event_engine/executor/executor.h"
-#include "src/core/lib/event_engine/forkable.h"
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-class ThreadPool final : public Forkable, public Executor {
+class OriginalThreadPool final : public ThreadPool {
  public:
-  ThreadPool();
+  explicit OriginalThreadPool(size_t reserve_threads);
   // Asserts Quiesce was called.
-  ~ThreadPool() override;
+  ~OriginalThreadPool() override;
 
-  void Quiesce();
+  void Quiesce() override;
 
   // Run must not be called after Quiesce completes
   void Run(absl::AnyInvocable<void()> callback) override;
@@ -129,13 +126,12 @@ class ThreadPool final : public Forkable, public Executor {
   static void StartThread(StatePtr state, StartThreadReason reason);
   void Postfork();
 
-  const unsigned reserve_threads_ =
-      grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 32u);
-  const StatePtr state_ = std::make_shared<State>(reserve_threads_);
+  const size_t reserve_threads_;
+  const StatePtr state_;
   std::atomic<bool> quiesced_{false};
 };
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_ORIGINAL_THREAD_POOL_H

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

@@ -0,0 +1,50 @@
+// Copyright 2023 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_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_THREAD_POOL_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_THREAD_POOL_H
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <memory>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/forkable.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Interface for all EventEngine ThreadPool implementations
+class ThreadPool : public Forkable {
+ public:
+  // Asserts Quiesce was called.
+  ~ThreadPool() override = default;
+  // Shut down the pool, and wait for all threads to exit.
+  // This method is safe to call from within a ThreadPool thread.
+  virtual void Quiesce() = 0;
+  // Run must not be called after Quiesce completes
+  virtual void Run(absl::AnyInvocable<void()> callback) = 0;
+  virtual void Run(EventEngine::Closure* closure) = 0;
+};
+
+// Creates a default thread pool.
+std::shared_ptr<ThreadPool> MakeThreadPool(size_t reserve_threads);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_THREAD_POOL_H

data/src/core/lib/event_engine/{executor/executor.h → thread_pool/thread_pool_factory.cc}

@@ -1,4 +1,4 @@
-// Copyright 2022 gRPC authors.
+// Copyright 2023 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.
@@ -11,28 +11,30 @@
 // 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>
 
-#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
-#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
+#include <stddef.h>
 
-#include <grpc/support/port_platform.h>
+#include <memory>
 
-#include "absl/functional/any_invocable.h"
+#include <grpc/support/cpu.h>
 
-#include <grpc/event_engine/event_engine.h>
+#include "src/core/lib/event_engine/thread_pool/original_thread_pool.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
+#include "src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h"
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gpr/useful.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-// A subset of the EventEngine execution API. See event_engine.h for details
-class Executor {
- public:
-  virtual ~Executor() = default;
-  virtual void Run(EventEngine::Closure* closure) = 0;
-  virtual void Run(absl::AnyInvocable<void()> closure) = 0;
-};
+std::shared_ptr<ThreadPool> MakeThreadPool(size_t reserve_threads) {
+  if (grpc_core::IsWorkStealingEnabled()) {
+    return std::make_shared<WorkStealingThreadPool>(
+        grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u));
+  }
+  return std::make_shared<OriginalThreadPool>(reserve_threads);
+}
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
-
-#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H