grpc 1.47.0 → 1.49.0.pre1

data/src/core/lib/debug/stats.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <string>
 
 #include <grpc/support/atm.h>
@@ -33,10 +35,17 @@ typedef struct grpc_stats_data {
   gpr_atm histograms[GRPC_STATS_HISTOGRAM_BUCKETS];
 } grpc_stats_data;
 
-extern grpc_stats_data* grpc_stats_per_cpu_storage;
+namespace grpc_core {
+struct Stats {
+  size_t num_cores;
+  grpc_stats_data per_cpu[0];
+};
+extern Stats* const g_stats_data;
+}  // namespace grpc_core
 
 #define GRPC_THREAD_STATS_DATA() \
-  (&grpc_stats_per_cpu_storage[grpc_core::ExecCtx::Get()->starting_cpu()])
+  (&::grpc_core::g_stats_data    \
+        ->per_cpu[grpc_core::ExecCtx::Get()->starting_cpu()])
 
 /* Only collect stats if GRPC_COLLECT_STATS is defined or it is a debug build.
  */
@@ -53,8 +62,8 @@ extern grpc_stats_data* grpc_stats_per_cpu_storage;
 #define GRPC_STATS_INC_HISTOGRAM(histogram, index)
 #endif /* defined(GRPC_COLLECT_STATS) || !defined(NDEBUG) */
 
-void grpc_stats_init(void);
-void grpc_stats_shutdown(void);
+GRPC_DEPRECATED("function is no longer needed")
+inline void grpc_stats_init(void) {}
 void grpc_stats_collect(grpc_stats_data* output);
 // c = b-a
 void grpc_stats_diff(const grpc_stats_data* b, const grpc_stats_data* a,

data/src/core/lib/debug/stats_data.cc

@@ -22,9 +22,10 @@
 
 #include "src/core/lib/debug/stats_data.h"
 
+#include <inttypes.h>
+
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 
 const char* grpc_stats_counter_name[GRPC_STATS_COUNTER_COUNT] = {
     "client_calls_created",

data/src/core/lib/debug/stats_data.h

@@ -23,10 +23,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <inttypes.h>
-
-#include "src/core/lib/iomgr/exec_ctx.h"
-
 typedef enum {
   GRPC_STATS_COUNTER_CLIENT_CALLS_CREATED,
   GRPC_STATS_COUNTER_SERVER_CALLS_CREATED,

data/src/core/lib/debug/trace.h

@@ -19,13 +19,20 @@
 #ifndef GRPC_CORE_LIB_DEBUG_TRACE_H
 #define GRPC_CORE_LIB_DEBUG_TRACE_H
 
-#include <grpc/support/port_platform.h>
+#if defined(__has_feature)
+#if __has_feature(thread_sanitizer)
+#define GRPC_THREADSAFE_TRACER
+#endif
+#endif
 
-#include <stdbool.h>
+#include <grpc/support/port_platform.h>
 
-#include <grpc/support/atm.h>
+#ifdef GRPC_THREADSAFE_TRACER
+#include <atomic>
+#endif
 
 #include "src/core/lib/gprpp/global_config.h"
+#include "src/core/lib/gprpp/memory.h"
 
 GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_trace);
 
@@ -36,12 +43,6 @@ void grpc_tracer_init(const char* env_var_name);
 void grpc_tracer_init();
 void grpc_tracer_shutdown(void);
 
-#if defined(__has_feature)
-#if __has_feature(thread_sanitizer)
-#define GRPC_THREADSAFE_TRACER
-#endif
-#endif
-
 namespace grpc_core {
 
 class TraceFlag;
@@ -80,7 +81,7 @@ class TraceFlag {
 #if defined(GRPC_USE_TRACERS) || !defined(NDEBUG)
   bool enabled() {
 #ifdef GRPC_THREADSAFE_TRACER
-    return gpr_atm_no_barrier_load(&value_) != 0;
+    return value_.load(std::memory_order_relaxed);
 #else
     return value_;
 #endif  // GRPC_THREADSAFE_TRACER
@@ -95,7 +96,7 @@ class TraceFlag {
 
   void set_enabled(bool enabled) {
 #ifdef GRPC_THREADSAFE_TRACER
-    gpr_atm_no_barrier_store(&value_, enabled);
+    value_.store(enabled, std::memory_order_relaxed);
 #else
     value_ = enabled;
 #endif
@@ -104,7 +105,7 @@ class TraceFlag {
   TraceFlag* next_tracer_;
   const char* const name_;
 #ifdef GRPC_THREADSAFE_TRACER
-  gpr_atm value_;
+  std::atomic<bool> value_;
 #else
   bool value_;
 #endif

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

@@ -0,0 +1,71 @@
+// 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.
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/event_engine/default_event_engine.h"
+
+#include <atomic>
+#include <memory>
+#include <utility>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/default_event_engine_factory.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+std::atomic<absl::AnyInvocable<std::unique_ptr<EventEngine>()>*>
+    g_event_engine_factory{nullptr};
+std::atomic<EventEngine*> g_event_engine{nullptr};
+}  // namespace
+
+void SetDefaultEventEngineFactory(
+    absl::AnyInvocable<std::unique_ptr<EventEngine>()> factory) {
+  delete g_event_engine_factory.exchange(
+      new absl::AnyInvocable<std::unique_ptr<EventEngine>()>(
+          std::move(factory)));
+}
+
+std::unique_ptr<EventEngine> CreateEventEngine() {
+  if (auto* factory = g_event_engine_factory.load()) {
+    return (*factory)();
+  }
+  return DefaultEventEngineFactory();
+}
+
+EventEngine* GetDefaultEventEngine() {
+  EventEngine* engine = g_event_engine.load(std::memory_order_acquire);
+  if (engine == nullptr) {
+    auto* created = CreateEventEngine().release();
+    if (g_event_engine.compare_exchange_strong(engine, created,
+                                               std::memory_order_acq_rel,
+                                               std::memory_order_acquire)) {
+      engine = created;
+    } else {
+      delete created;
+    }
+  }
+  return engine;
+}
+
+void ResetDefaultEventEngine() {
+  delete g_event_engine.exchange(nullptr, std::memory_order_acq_rel);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/{event_engine_factory.h → default_event_engine.h}

@@ -11,12 +11,11 @@
 // 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_EVENT_ENGINE_FACTORY_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H
 
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H
 
-#include <memory>
+#include <grpc/support/port_platform.h>
 
 #include <grpc/event_engine/event_engine.h>
 
@@ -29,13 +28,10 @@ namespace experimental {
 /// Strongly consider whether you could use \a CreateEventEngine instead.
 EventEngine* GetDefaultEventEngine();
 
-/// Create an EventEngine using the default factory provided at link time.
-std::unique_ptr<EventEngine> DefaultEventEngineFactory();
-
-// TODO(hork): remove this when any other EE usage is landed
-void InitializeEventEngine();
+/// Reset the default event engine
+void ResetDefaultEventEngine();
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H

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

@@ -11,23 +11,40 @@
 // 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/default_event_engine_factory.h"
+
 #include <memory>
 
 #include "absl/memory/memory.h"
 
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/event_engine_factory.h"
-#include "src/core/lib/event_engine/iomgr_engine.h"
+#ifdef GPR_WINDOWS
+#include "src/core/lib/event_engine/windows/windows_engine.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
+  return absl::make_unique<WindowsEventEngine>();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+#else  // not GPR_WINDOWS
+#include "src/core/lib/event_engine/posix_engine/posix_engine.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
 std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
-  return absl::make_unique<IomgrEventEngine>();
+  return absl::make_unique<PosixEventEngine>();
 }
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
+
+#endif

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

@@ -0,0 +1,33 @@
+// 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_DEFAULT_EVENT_ENGINE_FACTORY_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_FACTORY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// Create an EventEngine using the default factory provided at link time.
+std::unique_ptr<EventEngine> DefaultEventEngineFactory();
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_FACTORY_H

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

@@ -0,0 +1,38 @@
+// 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_EXECUTOR_EXECUTOR_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.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;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H

data/src/core/lib/event_engine/executor/threaded_executor.cc

@@ -0,0 +1,36 @@
+// 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/executor/threaded_executor.h"
+
+#include <utility>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+ThreadedExecutor::ThreadedExecutor(int reserve_threads)
+    : thread_pool_(reserve_threads){};
+
+void ThreadedExecutor::Run(EventEngine::Closure* closure) {
+  thread_pool_.Add([closure]() { closure->Run(); });
+}
+
+void ThreadedExecutor::Run(absl::AnyInvocable<void()> closure) {
+  thread_pool_.Add(std::move(closure));
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/executor/threaded_executor.h

@@ -0,0 +1,44 @@
+// 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_EXECUTOR_THREADED_EXECUTOR_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/executor/executor.h"
+#include "src/core/lib/event_engine/thread_pool.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class ThreadedExecutor : public Executor {
+ public:
+  explicit ThreadedExecutor(int reserve_threads);
+  ~ThreadedExecutor() override = default;
+  void Run(EventEngine::Closure* closure) override;
+  void Run(absl::AnyInvocable<void()> closure) override;
+
+ private:
+  ThreadPool thread_pool_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H

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

@@ -0,0 +1,98 @@
+// 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/forkable.h"
+
+#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
+#include <pthread.h>
+
+#include "absl/container/flat_hash_set.h"
+
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+grpc_core::Mutex g_mu;
+bool g_registered{false};
+absl::flat_hash_set<Forkable*> g_forkables;
+}  // namespace
+
+Forkable::Forkable() { ManageForkable(this); }
+
+Forkable::~Forkable() { StopManagingForkable(this); }
+
+void RegisterForkHandlers() {
+  grpc_core::MutexLock lock(&g_mu);
+  GPR_ASSERT(!absl::exchange(g_registered, true));
+  pthread_atfork(PrepareFork, PostforkParent, PostforkChild);
+};
+
+void PrepareFork() {
+  grpc_core::MutexLock lock(&g_mu);
+  for (auto* forkable : g_forkables) {
+    forkable->PrepareFork();
+  }
+}
+void PostforkParent() {
+  grpc_core::MutexLock lock(&g_mu);
+  for (auto* forkable : g_forkables) {
+    forkable->PostforkParent();
+  }
+}
+
+void PostforkChild() {
+  grpc_core::MutexLock lock(&g_mu);
+  for (auto* forkable : g_forkables) {
+    forkable->PostforkChild();
+  }
+}
+
+void ManageForkable(Forkable* forkable) {
+  grpc_core::MutexLock lock(&g_mu);
+  g_forkables.insert(forkable);
+}
+
+void StopManagingForkable(Forkable* forkable) {
+  grpc_core::MutexLock lock(&g_mu);
+  g_forkables.erase(forkable);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#else  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
+namespace grpc_event_engine {
+namespace experimental {
+
+Forkable::Forkable() {}
+Forkable::~Forkable() {}
+
+void RegisterForkHandlers() {}
+void PrepareFork() {}
+void PostforkParent() {}
+void PostforkChild() {}
+
+void ManageForkable(Forkable* /* forkable */) {}
+void StopManagingForkable(Forkable* /* forkable */) {}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK

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

@@ -0,0 +1,61 @@
+// 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_FORKABLE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
+
+#include <grpc/support/port_platform.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Register fork handlers with the system, enabling fork support.
+//
+// This provides pthread-based support for fork events. Any objects that
+// implement Forkable can register themselves with this system using
+// ManageForkable, and their respective methods will be called upon fork.
+//
+// This should be called once upon grpc_initialization.
+void RegisterForkHandlers();
+
+// Global callback for pthread_atfork's *prepare argument
+void PrepareFork();
+// Global callback for pthread_atfork's *parent argument
+void PostforkParent();
+// Global callback for pthread_atfork's *child argument
+void PostforkChild();
+
+// An interface to be implemented by EventEngines that wish to have managed fork
+// support.
+class Forkable {
+ public:
+  Forkable();
+  virtual ~Forkable();
+  virtual void PrepareFork() = 0;
+  virtual void PostforkParent() = 0;
+  virtual void PostforkChild() = 0;
+};
+
+// Add Forkables from the set of objects that are supported.
+// Upon fork, each forkable will have its respective fork hooks called on
+// the thread that invoked the fork.
+//
+// Relative ordering of fork callback operations is not guaranteed.
+void ManageForkable(Forkable* forkable);
+// Remove a forkable from the managed set.
+void StopManagingForkable(Forkable* forkable);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H

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

@@ -0,0 +1,54 @@
+// 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_POLLER_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POLLER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/types/variant.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// A generic cross-platform "poller" concept.
+// Concrete implementations will likely manage a set of sockets/file
+// descriptors/etc, allowing threads to drive polling and event processing via
+// Work(...).
+class Poller {
+ public:
+  // This initial vector size may need to be tuned
+  using Events = absl::InlinedVector<EventEngine::Closure*, 5>;
+  struct DeadlineExceeded {};
+  struct Kicked {};
+  using WorkResult = absl::variant<Events, DeadlineExceeded, Kicked>;
+
+  virtual ~Poller() = default;
+  // Poll once for events, returning a collection of Closures to be executed.
+  //
+  // Returns:
+  //  * absl::AbortedError if it was Kicked.
+  //  * absl::DeadlineExceeded if timeout occurred
+  //  * A collection of closures to execute, otherwise
+  virtual WorkResult Work(EventEngine::Duration timeout) = 0;
+  // Trigger the threads executing Work(..) to break out as soon as possible.
+  virtual void Kick() = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POLLER_H