grpc 1.50.0.pre1 → 1.51.0

data/src/core/lib/event_engine/posix_engine/wakeup_fd_pipe.cc

@@ -0,0 +1,151 @@
+// Copyright 2022 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.
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+#include <utility>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/support/log.h>  // IWYU pragma: keep
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_WAKEUP_FD
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
+#endif
+
+#include "src/core/lib/event_engine/posix_engine/wakeup_fd_pipe.h"
+#include "src/core/lib/gprpp/strerror.h"
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+#ifdef GRPC_POSIX_WAKEUP_FD
+
+namespace {
+
+absl::Status SetSocketNonBlocking(int fd) {
+  int oldflags = fcntl(fd, F_GETFL, 0);
+  if (oldflags < 0) {
+    return absl::Status(absl::StatusCode::kInternal,
+                        absl::StrCat("fcntl: ", grpc_core::StrError(errno)));
+  }
+
+  oldflags |= O_NONBLOCK;
+
+  if (fcntl(fd, F_SETFL, oldflags) != 0) {
+    return absl::Status(absl::StatusCode::kInternal,
+                        absl::StrCat("fcntl: ", grpc_core::StrError(errno)));
+  }
+
+  return absl::OkStatus();
+}
+}  // namespace
+
+absl::Status PipeWakeupFd::Init() {
+  int pipefd[2];
+  int r = pipe(pipefd);
+  if (0 != r) {
+    return absl::Status(absl::StatusCode::kInternal,
+                        absl::StrCat("pipe: ", grpc_core::StrError(errno)));
+  }
+  auto status = SetSocketNonBlocking(pipefd[0]);
+  if (!status.ok()) return status;
+  status = SetSocketNonBlocking(pipefd[1]);
+  if (!status.ok()) return status;
+  SetWakeupFds(pipefd[0], pipefd[1]);
+  return absl::OkStatus();
+}
+
+absl::Status PipeWakeupFd::ConsumeWakeup() {
+  char buf[128];
+  ssize_t r;
+
+  for (;;) {
+    r = read(ReadFd(), buf, sizeof(buf));
+    if (r > 0) continue;
+    if (r == 0) return absl::OkStatus();
+    switch (errno) {
+      case EAGAIN:
+        return absl::OkStatus();
+      case EINTR:
+        continue;
+      default:
+        return absl::Status(absl::StatusCode::kInternal,
+                            absl::StrCat("read: ", grpc_core::StrError(errno)));
+    }
+  }
+}
+
+absl::Status PipeWakeupFd::Wakeup() {
+  char c = 0;
+  while (write(WriteFd(), &c, 1) != 1 && errno == EINTR) {
+  }
+  return absl::OkStatus();
+}
+
+PipeWakeupFd::~PipeWakeupFd() {
+  if (ReadFd() != 0) {
+    close(ReadFd());
+  }
+  if (WriteFd() != 0) {
+    close(WriteFd());
+  }
+}
+
+bool PipeWakeupFd::IsSupported() {
+  PipeWakeupFd pipe_wakeup_fd;
+  return pipe_wakeup_fd.Init().ok();
+}
+
+absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd() {
+  static bool kIsPipeWakeupFdSupported = PipeWakeupFd::IsSupported();
+  if (kIsPipeWakeupFdSupported) {
+    auto pipe_wakeup_fd = std::make_unique<PipeWakeupFd>();
+    auto status = pipe_wakeup_fd->Init();
+    if (status.ok()) {
+      return std::unique_ptr<WakeupFd>(std::move(pipe_wakeup_fd));
+    }
+    return status;
+  }
+  return absl::NotFoundError("Pipe wakeup fd is not supported");
+}
+
+#else  //  GRPC_POSIX_WAKEUP_FD
+
+absl::Status PipeWakeupFd::Init() { GPR_ASSERT(false && "unimplemented"); }
+
+absl::Status PipeWakeupFd::ConsumeWakeup() {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+absl::Status PipeWakeupFd::Wakeup() { GPR_ASSERT(false && "unimplemented"); }
+
+bool PipeWakeupFd::IsSupported() { return false; }
+
+absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd() {
+  return absl::NotFoundError("Pipe wakeup fd is not supported");
+}
+
+#endif  //  GRPC_POSIX_WAKEUP_FD
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,45 @@
+// Copyright 2022 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_POSIX_ENGINE_WAKEUP_FD_PIPE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_PIPE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+class PipeWakeupFd : public WakeupFd {
+ public:
+  PipeWakeupFd() : WakeupFd() {}
+  ~PipeWakeupFd() override;
+  absl::Status ConsumeWakeup() override;
+  absl::Status Wakeup() override;
+  static absl::StatusOr<std::unique_ptr<WakeupFd>> CreatePipeWakeupFd();
+  static bool IsSupported();
+
+ private:
+  absl::Status Init();
+};
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_PIPE_H

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

@@ -0,0 +1,76 @@
+// Copyright 2022 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.
+
+/*
+ * WakeupFd abstracts the concept of a file descriptor for the purpose of
+ * waking up a thread in select()/poll()/epoll_wait()/etc.
+
+ * The poll() family of system calls provide a way for a thread to block until
+ * there is activity on one (or more) of a set of file descriptors. An
+ * application may wish to wake up this thread to do non file related work. The
+ * typical way to do this is to add a pipe to the set of file descriptors, then
+ * write to the pipe to wake up the thread in poll().
+ *
+ * Linux has a lighter weight eventfd specifically designed for this purpose.
+ * WakeupFd abstracts the difference between the two.
+ *
+ * Setup:
+ * 1. Call CreateWakeupFd() to crete an initialized WakeupFd.
+ * 2. Add the result of WakeupFd::ReadFd() to the set of monitored file
+ *    descriptors for the poll() style API you are using. Monitor the file
+ *    descriptor for readability.
+ * 3. To tear down, call WakeupFd::Destroy(). This closes the underlying
+ *    file descriptor.
+ *
+ * Usage:
+ * 1. To wake up a polling thread, call WakeupFd::Wakeup() on a wakeup_fd
+ *    it is monitoring.
+ * 2. If the polling thread was awakened by a WakeupFd event, call
+ *    WakeupFd::Consume() on it.
+ */
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/status/status.h"
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+class WakeupFd {
+ public:
+  virtual absl::Status ConsumeWakeup() = 0;
+  virtual absl::Status Wakeup() = 0;
+  virtual ~WakeupFd() = default;
+
+  int ReadFd() { return read_fd_; }
+  int WriteFd() { return write_fd_; }
+
+ protected:
+  WakeupFd() : read_fd_(0), write_fd_(0) {}
+  void SetWakeupFds(int read_fd, int write_fd) {
+    read_fd_ = read_fd;
+    write_fd_ = write_fd;
+  }
+
+ private:
+  int read_fd_;
+  int write_fd_;
+};
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H

data/src/core/lib/event_engine/posix_engine/wakeup_fd_posix_default.cc

@@ -0,0 +1,67 @@
+// Copyright 2022 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.
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/event_engine/posix_engine/wakeup_fd_eventfd.h"
+#include "src/core/lib/event_engine/posix_engine/wakeup_fd_pipe.h"
+#include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
+#include "src/core/lib/iomgr/port.h"
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+#ifdef GRPC_POSIX_WAKEUP_FD
+
+absl::StatusOr<std::unique_ptr<WakeupFd>> NotSupported() {
+  return absl::NotFoundError("Wakeup-fd is not supported on this system");
+}
+
+namespace {
+absl::StatusOr<std::unique_ptr<WakeupFd>> (*g_wakeup_fd_fn)() =
+    []() -> absl::StatusOr<std::unique_ptr<WakeupFd>> (*)() {
+#ifndef GRPC_POSIX_NO_SPECIAL_WAKEUP_FD
+  if (EventFdWakeupFd::IsSupported()) {
+    return &EventFdWakeupFd::CreateEventFdWakeupFd;
+  }
+#endif  // GRPC_POSIX_NO_SPECIAL_WAKEUP_FD
+  if (PipeWakeupFd::IsSupported()) {
+    return &PipeWakeupFd::CreatePipeWakeupFd;
+  }
+  return NotSupported;
+}();
+}  // namespace
+
+bool SupportsWakeupFd() { return g_wakeup_fd_fn != NotSupported; }
+
+absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd() {
+  return g_wakeup_fd_fn();
+}
+
+#else /* GRPC_POSIX_WAKEUP_FD */
+
+bool SupportsWakeupFd() { return false; }
+
+absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd() {
+  return absl::NotFoundError("Wakeup-fd is not supported on this system");
+}
+
+#endif /* GRPC_POSIX_WAKEUP_FD */
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,37 @@
+// Copyright 2022 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_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "absl/status/statusor.h"
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+class WakeupFd;
+
+// Returns true if wakeup-fd is supported by the system.
+bool SupportsWakeupFd();
+
+// Create and return an initialized WakeupFd instance if supported.
+absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd();
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H

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

@@ -14,6 +14,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/slice/slice.h"
+
 #include <stdint.h>
 
 #include <string>
@@ -25,14 +27,13 @@
 
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount.h"
-#include "src/core/lib/slice/slice_refcount_base.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
 namespace slice_detail {
 
-uint32_t BaseSlice::Hash() const { return grpc_slice_hash_internal(slice_); }
+uint32_t BaseSlice::Hash() const { return grpc_slice_hash(slice_); }
 
 template <>
 MutableSlice CopyConstructors<MutableSlice>::FromCopiedString(std::string s) {
@@ -51,7 +52,7 @@ MutableSlice::MutableSlice(const grpc_slice& slice)
   GPR_DEBUG_ASSERT(slice.refcount == nullptr || slice.refcount->IsUnique());
 }
 
-MutableSlice::~MutableSlice() { grpc_slice_unref_internal(c_slice()); }
+MutableSlice::~MutableSlice() { grpc_core::CSliceUnref(c_slice()); }
 
 Slice Slice::TakeOwned() {
   if (c_slice().refcount == nullptr) {
@@ -70,7 +71,7 @@ Slice Slice::AsOwned() const {
   if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
     return Slice(grpc_slice_copy(c_slice()));
   }
-  return Slice(grpc_slice_ref_internal(c_slice()));
+  return Slice(grpc_core::CSliceRef(c_slice()));
 }
 
 MutableSlice Slice::TakeMutable() {
@@ -84,9 +85,9 @@ MutableSlice Slice::TakeMutable() {
   return MutableSlice(grpc_slice_copy(c_slice()));
 }
 
-Slice::~Slice() { grpc_slice_unref_internal(c_slice()); }
+Slice::~Slice() { grpc_core::CSliceUnref(c_slice()); }
 
-Slice Slice::Ref() const { return Slice(grpc_slice_ref_internal(c_slice())); }
+Slice Slice::Ref() const { return Slice(grpc_core::CSliceRef(c_slice())); }
 
 Slice Slice::FromRefcountAndBytes(grpc_slice_refcount* r, const uint8_t* begin,
                                   const uint8_t* end) {

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

@@ -21,7 +21,7 @@
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 
-#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/slice/slice.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -43,7 +43,7 @@ void SliceBuffer::Prepend(Slice slice) {
 }
 
 Slice SliceBuffer::RefSlice(size_t index) {
-  return Slice(grpc_slice_ref_internal(slice_buffer_.slices[index]));
+  return Slice(grpc_core::CSliceRef(slice_buffer_.slices[index]));
 }
 
 }  // namespace experimental

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

@@ -20,16 +20,18 @@
 
 #include "src/core/lib/event_engine/thread_pool.h"
 
+#include <atomic>
 #include <memory>
 #include <utility>
 
+#include "absl/base/attributes.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/thd.h"
+#include "src/core/lib/gprpp/time.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -37,27 +39,63 @@ namespace experimental {
 namespace {
 // TODO(drfloob): Remove this, and replace it with the WorkQueue* for the
 // current thread (with nullptr indicating not a threadpool thread).
-GPR_THREAD_LOCAL(bool) g_threadpool_thread;
+thread_local bool g_threadpool_thread;
 }  // namespace
 
-void ThreadPool::StartThread(StatePtr state, bool throttled) {
+void ThreadPool::StartThread(StatePtr state, StartThreadReason reason) {
   state->thread_count.Add();
+  const auto now = grpc_core::Timestamp::Now();
+  switch (reason) {
+    case StartThreadReason::kNoWaitersWhenScheduling: {
+      auto time_since_last_start =
+          now - grpc_core::Timestamp::FromMillisecondsAfterProcessEpoch(
+                    state->last_started_thread.load(std::memory_order_relaxed));
+      if (time_since_last_start < grpc_core::Duration::Seconds(1)) {
+        state->thread_count.Remove();
+        return;
+      }
+    }
+      ABSL_FALLTHROUGH_INTENDED;
+    case StartThreadReason::kNoWaitersWhenFinishedStarting:
+      if (state->currently_starting_one_thread.exchange(
+              true, std::memory_order_relaxed)) {
+        state->thread_count.Remove();
+        return;
+      }
+      state->last_started_thread.store(now.milliseconds_after_process_epoch(),
+                                       std::memory_order_relaxed);
+      break;
+    case StartThreadReason::kInitialPool:
+      break;
+  }
   struct ThreadArg {
     StatePtr state;
-    bool throttled;
+    StartThreadReason reason;
   };
   grpc_core::Thread(
       "event_engine",
       [](void* arg) {
         std::unique_ptr<ThreadArg> a(static_cast<ThreadArg*>(arg));
         g_threadpool_thread = true;
-        if (a->throttled) {
-          GPR_ASSERT(a->state->currently_starting_one_thread.exchange(
-              false, std::memory_order_relaxed));
+        switch (a->reason) {
+          case StartThreadReason::kInitialPool:
+            break;
+          case StartThreadReason::kNoWaitersWhenFinishedStarting:
+            a->state->queue.SleepIfRunning();
+            ABSL_FALLTHROUGH_INTENDED;
+          case StartThreadReason::kNoWaitersWhenScheduling:
+            // Release throttling variable
+            GPR_ASSERT(a->state->currently_starting_one_thread.exchange(
+                false, std::memory_order_relaxed));
+            if (a->state->queue.IsBacklogged()) {
+              StartThread(a->state,
+                          StartThreadReason::kNoWaitersWhenFinishedStarting);
+            }
+            break;
         }
         ThreadFunc(a->state);
       },
-      new ThreadArg{state, throttled}, nullptr,
+      new ThreadArg{state, reason}, nullptr,
       grpc_core::Thread::Options().set_tracked(false).set_joinable(false))
       .Start();
 }
@@ -74,10 +112,18 @@ bool ThreadPool::Queue::Step() {
   while (state_ == State::kRunning && callbacks_.empty()) {
     // If there are too many threads waiting, then quit this thread.
     // TODO(ctiller): wait some time in this case to be sure.
-    if (threads_waiting_ >= reserve_threads_) return false;
-    threads_waiting_++;
-    cv_.Wait(&mu_);
-    threads_waiting_--;
+    if (threads_waiting_ >= reserve_threads_) {
+      threads_waiting_++;
+      bool timeout = cv_.WaitWithTimeout(&mu_, absl::Seconds(30));
+      threads_waiting_--;
+      if (timeout && threads_waiting_ >= reserve_threads_) {
+        return false;
+      }
+    } else {
+      threads_waiting_++;
+      cv_.Wait(&mu_);
+      threads_waiting_--;
+    }
   }
   switch (state_) {
     case State::kRunning:
@@ -95,14 +141,13 @@ bool ThreadPool::Queue::Step() {
   return true;
 }
 
-ThreadPool::ThreadPool(int reserve_threads)
-    : reserve_threads_(reserve_threads) {
-  for (int i = 0; i < reserve_threads; i++) {
-    StartThread(state_, /*throttled=*/false);
+ThreadPool::ThreadPool() {
+  for (unsigned i = 0; i < reserve_threads_; i++) {
+    StartThread(state_, StartThreadReason::kInitialPool);
   }
 }
 
-ThreadPool::~ThreadPool() {
+void ThreadPool::Quiesce() {
   state_->queue.SetShutdown();
   // Wait until all threads are exited.
   // Note that if this is a threadpool thread then we won't exit this thread
@@ -110,17 +155,24 @@ ThreadPool::~ThreadPool() {
   // thread running instead of zero.
   state_->thread_count.BlockUntilThreadCount(g_threadpool_thread ? 1 : 0,
                                              "shutting down");
+  quiesced_.store(true, std::memory_order_relaxed);
+}
+
+ThreadPool::~ThreadPool() {
+  GPR_ASSERT(quiesced_.load(std::memory_order_relaxed));
 }
 
-void ThreadPool::Add(absl::AnyInvocable<void()> callback) {
+void ThreadPool::Run(absl::AnyInvocable<void()> callback) {
+  GPR_DEBUG_ASSERT(quiesced_.load(std::memory_order_relaxed) == false);
   if (state_->queue.Add(std::move(callback))) {
-    if (!state_->currently_starting_one_thread.exchange(
-            true, std::memory_order_relaxed)) {
-      StartThread(state_, /*throttled=*/true);
-    }
+    StartThread(state_, StartThreadReason::kNoWaitersWhenScheduling);
   }
 }
 
+void ThreadPool::Run(EventEngine::Closure* closure) {
+  Run([closure]() { closure->Run(); });
+}
+
 bool ThreadPool::Queue::Add(absl::AnyInvocable<void()> callback) {
   grpc_core::MutexLock lock(&mu_);
   // Add works to the callbacks list
@@ -129,13 +181,42 @@ bool ThreadPool::Queue::Add(absl::AnyInvocable<void()> callback) {
   switch (state_) {
     case State::kRunning:
     case State::kShutdown:
-      return threads_waiting_ == 0;
+      return callbacks_.size() > threads_waiting_;
     case State::kForking:
       return false;
   }
   GPR_UNREACHABLE_CODE(return false);
 }
 
+bool ThreadPool::Queue::IsBacklogged() {
+  grpc_core::MutexLock lock(&mu_);
+  switch (state_) {
+    case State::kRunning:
+    case State::kShutdown:
+      return callbacks_.size() > 1;
+    case State::kForking:
+      return false;
+  }
+  GPR_UNREACHABLE_CODE(return false);
+}
+
+void ThreadPool::Queue::SleepIfRunning() {
+  grpc_core::MutexLock lock(&mu_);
+  auto end = grpc_core::Duration::Seconds(1) + grpc_core::Timestamp::Now();
+  while (true) {
+    grpc_core::Timestamp now = grpc_core::Timestamp::Now();
+    if (now >= end) return;
+    switch (state_) {
+      case State::kRunning:
+      case State::kShutdown:
+        cv_.WaitWithTimeout(&mu_, absl::Milliseconds((end - now).millis()));
+        break;
+      case State::kForking:
+        return;
+    }
+  }
+}
+
 void ThreadPool::Queue::SetState(State state) {
   grpc_core::MutexLock lock(&mu_);
   if (state == State::kRunning) {
@@ -186,8 +267,8 @@ void ThreadPool::PostforkChild() { Postfork(); }
 
 void ThreadPool::Postfork() {
   state_->queue.Reset();
-  for (int i = 0; i < reserve_threads_; i++) {
-    StartThread(state_, /*throttled=*/false);
+  for (unsigned i = 0; i < reserve_threads_; i++) {
+    StartThread(state_, StartThreadReason::kInitialPool);
   }
 }