grpc 1.61.3 → 1.62.0.pre1

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

@@ -0,0 +1,85 @@
+// Copyright 2023 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_QUERY_EXTENSIONS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_QUERY_EXTENSIONS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace endpoint_detail {
+
+template <typename Querying, typename... Es>
+struct QueryExtensionRecursion;
+
+template <typename Querying, typename E, typename... Es>
+struct QueryExtensionRecursion<Querying, E, Es...> {
+  static void* Query(absl::string_view id, Querying* p) {
+    if (id == E::EndpointExtensionName()) return static_cast<E*>(p);
+    return QueryExtensionRecursion<Querying, Es...>::Query(id, p);
+  }
+};
+
+template <typename Querying>
+struct QueryExtensionRecursion<Querying> {
+  static void* Query(absl::string_view, Querying*) { return nullptr; }
+};
+
+}  // namespace endpoint_detail
+
+// A helper class to derive from some set of base classes and export
+// QueryExtension for them all.
+// EventEngine Extensible object implementations which need to support different
+// extensions just need to derive from this class.
+template <typename EEClass, typename... Exports>
+class ExtendedType : public EEClass, public Exports... {
+ public:
+  void* QueryExtension(absl::string_view id) override {
+    return endpoint_detail::QueryExtensionRecursion<ExtendedType,
+                                                    Exports...>::Query(id,
+                                                                       this);
+  }
+};
+
+/// A helper method which returns a valid pointer if the extension is
+/// supported by the endpoint.
+template <typename T>
+T* QueryExtension(EventEngine::Endpoint* endpoint) {
+  if (endpoint == nullptr) return nullptr;
+  return static_cast<T*>(endpoint->QueryExtension(T::EndpointExtensionName()));
+}
+
+/// A helper method which returns a valid pointer if the extension is
+/// supported by the listener.
+template <typename T>
+T* QueryExtension(EventEngine::Listener* listener) {
+  return static_cast<T*>(listener->QueryExtension(T::EndpointExtensionName()));
+}
+
+/// A helper method which returns a valid pointer if the extension is
+/// supported by the EventEngine.
+template <typename T>
+T* QueryExtension(EventEngine* engine) {
+  return static_cast<T*>(engine->QueryExtension(T::EndpointExtensionName()));
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_QUERY_EXTENSIONS_H

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

@@ -22,18 +22,13 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
-bool g_event_engine_supports_fd = true;
-#else
-bool g_event_engine_supports_fd = false;
-#endif
-
 bool UseEventEngineClient() {
 // TODO(hork, eryu): Adjust the ifdefs accordingly when event engines become
 // available for other platforms.
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM)
+#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM) && \
+    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
   return grpc_core::IsEventEngineClientEnabled();
-#elif defined(GPR_WINDOWS)
+#elif defined(GPR_WINDOWS) && !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
   return grpc_core::IsEventEngineClientEnabled();
 #elif defined(GRPC_IOS_EVENT_ENGINE_CLIENT)
   return true;
@@ -53,14 +48,5 @@ bool UseEventEngineListener() {
 #endif
 }
 
-bool EventEngineSupportsFd() {
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM) && \
-    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
-  return g_event_engine_supports_fd;
-#else
-  return false;
-#endif
-}
-
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -25,8 +25,6 @@ bool UseEventEngineClient();
 
 bool UseEventEngineListener();
 
-bool EventEngineSupportsFd();
-
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

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

@@ -17,27 +17,48 @@
 
 #include <inttypes.h>
 
+#include <cstddef>
+
+#include "absl/status/status.h"
+#include "absl/strings/str_format.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/time.h"
+
 namespace grpc_event_engine {
 namespace experimental {
 
 // -------- LivingThreadCount --------
 
-void LivingThreadCount::BlockUntilThreadCount(size_t desired_threads,
-                                              const char* why) {
-  constexpr grpc_core::Duration log_rate = grpc_core::Duration::Seconds(3);
+absl::Status LivingThreadCount::BlockUntilThreadCount(
+    size_t desired_threads, const char* why,
+    grpc_core::Duration stuck_timeout) {
+  grpc_core::Timestamp timeout_baseline = grpc_core::Timestamp::Now();
+  constexpr grpc_core::Duration log_rate = grpc_core::Duration::Seconds(5);
+  size_t prev_thread_count = 0;
   while (true) {
-    auto curr_threads = WaitForCountChange(desired_threads, log_rate);
-    if (curr_threads == desired_threads) break;
+    auto curr_threads = WaitForCountChange(desired_threads, log_rate / 2);
+    if (curr_threads == desired_threads) return absl::OkStatus();
+    auto elapsed = grpc_core::Timestamp::Now() - timeout_baseline;
+    if (curr_threads == prev_thread_count) {
+      if (elapsed > stuck_timeout) {
+        return absl::DeadlineExceededError(absl::StrFormat(
+            "Timed out after %f seconds", stuck_timeout.seconds()));
+      }
+    } else {
+      // the thread count has changed. Reset the timeout clock
+      prev_thread_count = curr_threads;
+      timeout_baseline = grpc_core::Timestamp::Now();
+    }
     GRPC_LOG_EVERY_N_SEC_DELAYED(
         log_rate.seconds(), GPR_DEBUG,
         "Waiting for thread pool to idle before %s. (%" PRIdPTR " to %" PRIdPTR
-        ")",
-        why, curr_threads, desired_threads);
+        "). Timing out in %0.f seconds.",
+        why, curr_threads, desired_threads,
+        (stuck_timeout - elapsed).seconds());
   }
 }
 

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

@@ -151,7 +151,12 @@ class LivingThreadCount {
     --living_count_;
     cv_.SignalAll();
   }
-  void BlockUntilThreadCount(size_t desired_threads, const char* why)
+  // Blocks the calling thread until the desired number of threads is reached.
+  // If the thread count does not change for some given `stuck_timeout`
+  // duration, this method returns error. If the thread count does change, the
+  // timeout clock is reset.
+  absl::Status BlockUntilThreadCount(size_t desired_threads, const char* why,
+                                     grpc_core::Duration stuck_timeout)
       ABSL_LOCKS_EXCLUDED(mu_);
   size_t count() ABSL_LOCKS_EXCLUDED(mu_) {
     grpc_core::MutexLock lock(&mu_);

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

@@ -15,7 +15,6 @@
 // limitations under the License.
 //
 //
-
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h"
@@ -24,24 +23,36 @@
 
 #include <atomic>
 #include <chrono>
+#include <cstddef>
 #include <memory>
 #include <utility>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "absl/types/optional.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/thd_id.h>
 
 #include "src/core/lib/backoff/backoff.h"
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/common_closures.h"
 #include "src/core/lib/event_engine/thread_local.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/work_queue/basic_work_queue.h"
 #include "src/core/lib/event_engine/work_queue/work_queue.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/env.h"
+#include "src/core/lib/gprpp/examine_stack.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/gprpp/time.h"
 
+#ifdef GPR_POSIX_SYNC
+#include <csignal>
+#elif defined(GPR_WINDOWS)
+#include <signal.h>
+#endif
+
 // IWYU pragma: no_include <ratio>
 
 // ## Thread Pool Fork-handling
@@ -84,6 +95,13 @@
 // non-existent Lifeguard thread to finish. Trying a simple
 // `lifeguard_thread_.Join()` leads to memory access errors. This implementation
 // uses Notifications to coordinate startup and shutdown states.
+//
+// ## Debugging
+//
+// Set the environment variable GRPC_THREAD_POOL_VERBOSE_FAILURES=anything to
+// enable advanced debugging. When the pool takes too long to quiesce, a
+// backtrace will be printed for every running thread, and the process will
+// abort.
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -117,6 +135,37 @@ constexpr grpc_core::Duration kLifeguardMinSleepBetweenChecks{
 // Maximum time the lifeguard thread should sleep between checking for new work.
 constexpr grpc_core::Duration kLifeguardMaxSleepBetweenChecks{
     grpc_core::Duration::Seconds(1)};
+constexpr grpc_core::Duration kBlockUntilThreadCountTimeout{
+    grpc_core::Duration::Seconds(60)};
+
+#ifdef GPR_POSIX_SYNC
+const bool g_log_verbose_failures =
+    grpc_core::GetEnv("GRPC_THREAD_POOL_VERBOSE_FAILURES").has_value();
+constexpr int kDumpStackSignal = SIGUSR1;
+#elif defined(GPR_WINDOWS)
+const bool g_log_verbose_failures =
+    grpc_core::GetEnv("GRPC_THREAD_POOL_VERBOSE_FAILURES").has_value();
+constexpr int kDumpStackSignal = SIGTERM;
+#else
+constexpr bool g_log_verbose_failures = false;
+constexpr int kDumpStackSignal = -1;
+#endif
+
+std::atomic<size_t> g_reported_dump_count{0};
+
+void DumpSignalHandler(int /* sig */) {
+  const auto trace = grpc_core::GetCurrentStackTrace();
+  if (!trace.has_value()) {
+    gpr_log(GPR_ERROR, "DumpStack::%" PRIdPTR ": Stack trace not available",
+            gpr_thd_currentid());
+  } else {
+    gpr_log(GPR_ERROR, "DumpStack::%" PRIdPTR ": %s", gpr_thd_currentid(),
+            trace->c_str());
+  }
+  g_reported_dump_count.fetch_add(1);
+  grpc_core::Thread::Kill(gpr_thd_currentid());
+}
+
 }  // namespace
 
 thread_local WorkQueue* g_local_queue = nullptr;
@@ -125,6 +174,10 @@ thread_local WorkQueue* g_local_queue = nullptr;
 
 WorkStealingThreadPool::WorkStealingThreadPool(size_t reserve_threads)
     : pool_{std::make_shared<WorkStealingThreadPoolImpl>(reserve_threads)} {
+  if (g_log_verbose_failures) {
+    GRPC_EVENT_ENGINE_TRACE(
+        "%s", "WorkStealingThreadPool verbose failures are enabled");
+  }
   pool_->Start();
 }
 
@@ -221,8 +274,13 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Quiesce() {
   // running instead of zero.
   bool is_threadpool_thread = g_local_queue != nullptr;
   work_signal()->SignalAll();
-  living_thread_count_.BlockUntilThreadCount(is_threadpool_thread ? 1 : 0,
-                                             "shutting down");
+  auto threads_were_shut_down = living_thread_count_.BlockUntilThreadCount(
+      is_threadpool_thread ? 1 : 0, "shutting down",
+      g_log_verbose_failures ? kBlockUntilThreadCountTimeout
+                             : grpc_core::Duration::Infinity());
+  if (!threads_were_shut_down.ok() && g_log_verbose_failures) {
+    DumpStacksAndCrash();
+  }
   GPR_ASSERT(queue_.Empty());
   quiesced_.store(true, std::memory_order_relaxed);
   lifeguard_.BlockUntilShutdownAndReset();
@@ -262,7 +320,11 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::PrepareFork() {
   gpr_log(GPR_INFO, "WorkStealingThreadPoolImpl::PrepareFork");
   SetForking(true);
   work_signal_.SignalAll();
-  living_thread_count_.BlockUntilThreadCount(0, "forking");
+  auto threads_were_shut_down = living_thread_count_.BlockUntilThreadCount(
+      0, "forking", kBlockUntilThreadCountTimeout);
+  if (!threads_were_shut_down.ok() && g_log_verbose_failures) {
+    DumpStacksAndCrash();
+  }
   lifeguard_.BlockUntilShutdownAndReset();
 }
 
@@ -271,6 +333,37 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Postfork() {
   Start();
 }
 
+void WorkStealingThreadPool::WorkStealingThreadPoolImpl::TrackThread(
+    gpr_thd_id tid) {
+  grpc_core::MutexLock lock(&thd_set_mu_);
+  thds_.insert(tid);
+}
+
+void WorkStealingThreadPool::WorkStealingThreadPoolImpl::UntrackThread(
+    gpr_thd_id tid) {
+  grpc_core::MutexLock lock(&thd_set_mu_);
+  thds_.erase(tid);
+}
+
+void WorkStealingThreadPool::WorkStealingThreadPoolImpl::DumpStacksAndCrash() {
+  grpc_core::MutexLock lock(&thd_set_mu_);
+  gpr_log(GPR_ERROR,
+          "Pool did not quiesce in time, gRPC will not shut down cleanly. "
+          "Dumping all %zu thread stacks.",
+          thds_.size());
+  for (const auto tid : thds_) {
+    grpc_core::Thread::Signal(tid, kDumpStackSignal);
+  }
+  // If this is a thread pool thread, wait for one fewer thread.
+  auto ignore_thread_count = g_local_queue != nullptr ? 1 : 0;
+  while (living_thread_count_.count() - ignore_thread_count >
+         g_reported_dump_count.load()) {
+    absl::SleepFor(absl::Milliseconds(200));
+  }
+  grpc_core::Crash(
+      "Pool did not quiesce in time, gRPC will not shut down cleanly.");
+}
+
 // -------- WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard -----
 
 WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::Lifeguard(
@@ -388,6 +481,14 @@ WorkStealingThreadPool::ThreadState::ThreadState(
       busy_count_idx_(pool_->busy_thread_count()->NextIndex()) {}
 
 void WorkStealingThreadPool::ThreadState::ThreadBody() {
+  if (g_log_verbose_failures) {
+#ifdef GPR_POSIX_SYNC
+    std::signal(kDumpStackSignal, DumpSignalHandler);
+#elif defined(GPR_WINDOWS)
+    signal(kDumpStackSignal, DumpSignalHandler);
+#endif
+    pool_->TrackThread(gpr_thd_currentid());
+  }
   g_local_queue = new BasicWorkQueue(pool_.get());
   pool_->theft_registry()->Enroll(g_local_queue);
   ThreadLocal::SetIsEventEngineThread(true);
@@ -410,6 +511,9 @@ void WorkStealingThreadPool::ThreadState::ThreadBody() {
   GPR_ASSERT(g_local_queue->Empty());
   pool_->theft_registry()->Unenroll(g_local_queue);
   delete g_local_queue;
+  if (g_log_verbose_failures) {
+    pool_->UntrackThread(gpr_thd_currentid());
+  }
 }
 
 void WorkStealingThreadPool::ThreadState::SleepIfRunning() {

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

@@ -31,6 +31,7 @@
 #include "absl/functional/any_invocable.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/thd_id.h>
 
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/event_engine/thread_pool/thread_count.h"
@@ -132,6 +133,9 @@ class WorkStealingThreadPool final : public ThreadPool {
     // Postfork parent and child have the same behavior.
     void PrepareFork();
     void Postfork();
+    // Thread ID tracking
+    void TrackThread(gpr_thd_id tid);
+    void UntrackThread(gpr_thd_id tid);
     // Accessor methods
     bool IsShutdown();
     bool IsForking();
@@ -172,6 +176,8 @@ class WorkStealingThreadPool final : public ThreadPool {
       std::atomic<bool> lifeguard_running_{false};
     };
 
+    void DumpStacksAndCrash();
+
     const size_t reserve_threads_;
     BusyThreadCount busy_thread_count_;
     LivingThreadCount living_thread_count_;
@@ -190,6 +196,9 @@ class WorkStealingThreadPool final : public ThreadPool {
     std::atomic<bool> throttled_{false};
     WorkSignal work_signal_;
     Lifeguard lifeguard_;
+    // Set of threads for verbose failure debugging
+    grpc_core::Mutex thd_set_mu_;
+    absl::flat_hash_set<gpr_thd_id> thds_ ABSL_GUARDED_BY(thd_set_mu_);
   };
 
   class ThreadState {

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

@@ -29,7 +29,8 @@ namespace grpc_event_engine {
 namespace experimental {
 
 std::string HandleToStringInternal(uintptr_t a, uintptr_t b) {
-  return absl::StrCat("{", a, ",", b, "}");
+  return absl::StrCat("{", absl::Hex(a, absl::kZeroPad16), ",",
+                      absl::Hex(b, absl::kZeroPad16), "}");
 }
 
 grpc_core::Timestamp ToTimestamp(grpc_core::Timestamp now,

data/src/core/lib/event_engine/windows/grpc_polled_fd_windows.cc

@@ -24,6 +24,7 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_format.h"
 
 #include <grpc/support/log_windows.h>
 

data/src/core/lib/experiments/config.cc

@@ -94,8 +94,7 @@ class TestExperiments {
 
 TestExperiments* g_test_experiments = nullptr;
 
-GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariable() {
-  g_loaded.store(true, std::memory_order_relaxed);
+GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariableInner() {
   // Set defaults from metadata.
   Experiments experiments;
   for (size_t i = 0; i < kNumExperiments; i++) {
@@ -151,6 +150,11 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariable() {
   return experiments;
 }
 
+Experiments LoadExperimentsFromConfigVariable() {
+  g_loaded.store(true, std::memory_order_relaxed);
+  return LoadExperimentsFromConfigVariableInner();
+}
+
 Experiments& ExperimentsSingleton() {
   // One time initialization:
   static NoDestruct<Experiments> experiments{
@@ -174,6 +178,10 @@ bool IsExperimentEnabled(size_t experiment_id) {
   return ExperimentsSingleton().enabled[experiment_id];
 }
 
+bool IsExperimentEnabledInConfiguration(size_t experiment_id) {
+  return LoadExperimentsFromConfigVariableInner().enabled[experiment_id];
+}
+
 bool IsTestExperimentEnabled(size_t experiment_id) {
   return (*g_test_experiments)[experiment_id];
 }

data/src/core/lib/experiments/config.h

@@ -48,6 +48,12 @@ bool IsExperimentEnabled(size_t experiment_id);
 // method.
 bool IsTestExperimentEnabled(size_t experiment_id);
 
+// Slow check for if a named experiment is enabled.
+// Parses the configuration and looks up the experiment in that, so it does not
+// affect any global state, but it does require parsing the configuration every
+// call!
+bool IsExperimentEnabledInConfiguration(size_t experiment_id);
+
 // Reload experiment state from config variables.
 // Does not change ForceEnableExperiment state.
 // Expects the caller to handle global thread safety - so really only