grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

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

@@ -23,129 +23,270 @@
 
 #include <grpc/support/port_platform.h>
 
-// IWYU pragma: private, include "src/core/lib/debug/stats.h"
-
-typedef enum {
-  GRPC_STATS_COUNTER_CLIENT_CALLS_CREATED,
-  GRPC_STATS_COUNTER_SERVER_CALLS_CREATED,
-  GRPC_STATS_COUNTER_CLIENT_CHANNELS_CREATED,
-  GRPC_STATS_COUNTER_CLIENT_SUBCHANNELS_CREATED,
-  GRPC_STATS_COUNTER_SERVER_CHANNELS_CREATED,
-  GRPC_STATS_COUNTER_SYSCALL_WRITE,
-  GRPC_STATS_COUNTER_SYSCALL_READ,
-  GRPC_STATS_COUNTER_TCP_READ_ALLOC_8K,
-  GRPC_STATS_COUNTER_TCP_READ_ALLOC_64K,
-  GRPC_STATS_COUNTER_HTTP2_SETTINGS_WRITES,
-  GRPC_STATS_COUNTER_HTTP2_PINGS_SENT,
-  GRPC_STATS_COUNTER_HTTP2_WRITES_BEGUN,
-  GRPC_STATS_COUNTER_HTTP2_TRANSPORT_STALLS,
-  GRPC_STATS_COUNTER_HTTP2_STREAM_STALLS,
-  GRPC_STATS_COUNTER_CQ_PLUCK_CREATES,
-  GRPC_STATS_COUNTER_CQ_NEXT_CREATES,
-  GRPC_STATS_COUNTER_CQ_CALLBACK_CREATES,
-  GRPC_STATS_COUNTER_COUNT
-} grpc_stats_counters;
-extern const char* grpc_stats_counter_name[GRPC_STATS_COUNTER_COUNT];
-extern const char* grpc_stats_counter_doc[GRPC_STATS_COUNTER_COUNT];
-typedef enum {
-  GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE,
-  GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE,
-  GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE,
-  GRPC_STATS_HISTOGRAM_TCP_READ_SIZE,
-  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER,
-  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE,
-  GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE,
-  GRPC_STATS_HISTOGRAM_COUNT
-} grpc_stats_histograms;
-extern const char* grpc_stats_histogram_name[GRPC_STATS_HISTOGRAM_COUNT];
-extern const char* grpc_stats_histogram_doc[GRPC_STATS_HISTOGRAM_COUNT];
-typedef enum {
-  GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE_FIRST_SLOT = 0,
-  GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE_BUCKETS = 24,
-  GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE_FIRST_SLOT = 24,
-  GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE_BUCKETS = 20,
-  GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE_FIRST_SLOT = 44,
-  GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE_BUCKETS = 10,
-  GRPC_STATS_HISTOGRAM_TCP_READ_SIZE_FIRST_SLOT = 54,
-  GRPC_STATS_HISTOGRAM_TCP_READ_SIZE_BUCKETS = 20,
-  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_FIRST_SLOT = 74,
-  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_BUCKETS = 20,
-  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE_FIRST_SLOT = 94,
-  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE_BUCKETS = 10,
-  GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE_FIRST_SLOT = 104,
-  GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE_BUCKETS = 20,
-  GRPC_STATS_HISTOGRAM_BUCKETS = 124
-} grpc_stats_histogram_constants;
-#define GRPC_STATS_INC_CLIENT_CALLS_CREATED() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_CLIENT_CALLS_CREATED)
-#define GRPC_STATS_INC_SERVER_CALLS_CREATED() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_SERVER_CALLS_CREATED)
-#define GRPC_STATS_INC_CLIENT_CHANNELS_CREATED() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_CLIENT_CHANNELS_CREATED)
-#define GRPC_STATS_INC_CLIENT_SUBCHANNELS_CREATED() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_CLIENT_SUBCHANNELS_CREATED)
-#define GRPC_STATS_INC_SERVER_CHANNELS_CREATED() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_SERVER_CHANNELS_CREATED)
-#define GRPC_STATS_INC_SYSCALL_WRITE() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_SYSCALL_WRITE)
-#define GRPC_STATS_INC_SYSCALL_READ() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_SYSCALL_READ)
-#define GRPC_STATS_INC_TCP_READ_ALLOC_8K() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_TCP_READ_ALLOC_8K)
-#define GRPC_STATS_INC_TCP_READ_ALLOC_64K() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_TCP_READ_ALLOC_64K)
-#define GRPC_STATS_INC_HTTP2_SETTINGS_WRITES() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_HTTP2_SETTINGS_WRITES)
-#define GRPC_STATS_INC_HTTP2_PINGS_SENT() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_HTTP2_PINGS_SENT)
-#define GRPC_STATS_INC_HTTP2_WRITES_BEGUN() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_HTTP2_WRITES_BEGUN)
-#define GRPC_STATS_INC_HTTP2_TRANSPORT_STALLS() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_HTTP2_TRANSPORT_STALLS)
-#define GRPC_STATS_INC_HTTP2_STREAM_STALLS() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_HTTP2_STREAM_STALLS)
-#define GRPC_STATS_INC_CQ_PLUCK_CREATES() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_CQ_PLUCK_CREATES)
-#define GRPC_STATS_INC_CQ_NEXT_CREATES() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_CQ_NEXT_CREATES)
-#define GRPC_STATS_INC_CQ_CALLBACK_CREATES() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_CQ_CALLBACK_CREATES)
-#define GRPC_STATS_INC_CALL_INITIAL_SIZE(value) \
-  GRPC_STATS_INC_HISTOGRAM(                     \
-      GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE,   \
-      grpc_core::BucketForHistogramValue_32768_24(static_cast<int>(value)))
-#define GRPC_STATS_INC_TCP_WRITE_SIZE(value) \
-  GRPC_STATS_INC_HISTOGRAM(                  \
-      GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE,   \
-      grpc_core::BucketForHistogramValue_16777216_20(static_cast<int>(value)))
-#define GRPC_STATS_INC_TCP_WRITE_IOV_SIZE(value) \
-  GRPC_STATS_INC_HISTOGRAM(                      \
-      GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE,   \
-      grpc_core::BucketForHistogramValue_80_10(static_cast<int>(value)))
-#define GRPC_STATS_INC_TCP_READ_SIZE(value) \
-  GRPC_STATS_INC_HISTOGRAM(                 \
-      GRPC_STATS_HISTOGRAM_TCP_READ_SIZE,   \
-      grpc_core::BucketForHistogramValue_16777216_20(static_cast<int>(value)))
-#define GRPC_STATS_INC_TCP_READ_OFFER(value) \
-  GRPC_STATS_INC_HISTOGRAM(                  \
-      GRPC_STATS_HISTOGRAM_TCP_READ_OFFER,   \
-      grpc_core::BucketForHistogramValue_16777216_20(static_cast<int>(value)))
-#define GRPC_STATS_INC_TCP_READ_OFFER_IOV_SIZE(value) \
-  GRPC_STATS_INC_HISTOGRAM(                           \
-      GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE,   \
-      grpc_core::BucketForHistogramValue_80_10(static_cast<int>(value)))
-#define GRPC_STATS_INC_HTTP2_SEND_MESSAGE_SIZE(value) \
-  GRPC_STATS_INC_HISTOGRAM(                           \
-      GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE,   \
-      grpc_core::BucketForHistogramValue_16777216_20(static_cast<int>(value)))
+#include <stdint.h>
+
+#include <atomic>
+#include <memory>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/debug/histogram_view.h"
+#include "src/core/lib/gprpp/per_cpu.h"
+
 namespace grpc_core {
-int BucketForHistogramValue_32768_24(int value);
-int BucketForHistogramValue_16777216_20(int value);
-int BucketForHistogramValue_80_10(int value);
+class HistogramCollector_32768_24;
+class Histogram_32768_24 {
+ public:
+  static int BucketFor(int value);
+  const uint64_t* buckets() const { return buckets_; }
+  friend Histogram_32768_24 operator-(const Histogram_32768_24& left,
+                                      const Histogram_32768_24& right);
+
+ private:
+  friend class HistogramCollector_32768_24;
+  uint64_t buckets_[24]{};
+};
+class HistogramCollector_32768_24 {
+ public:
+  void Increment(int value) {
+    buckets_[Histogram_32768_24::BucketFor(value)].fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void Collect(Histogram_32768_24* result) const;
+
+ private:
+  std::atomic<uint64_t> buckets_[24]{};
+};
+class HistogramCollector_16777216_20;
+class Histogram_16777216_20 {
+ public:
+  static int BucketFor(int value);
+  const uint64_t* buckets() const { return buckets_; }
+  friend Histogram_16777216_20 operator-(const Histogram_16777216_20& left,
+                                         const Histogram_16777216_20& right);
+
+ private:
+  friend class HistogramCollector_16777216_20;
+  uint64_t buckets_[20]{};
+};
+class HistogramCollector_16777216_20 {
+ public:
+  void Increment(int value) {
+    buckets_[Histogram_16777216_20::BucketFor(value)].fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void Collect(Histogram_16777216_20* result) const;
+
+ private:
+  std::atomic<uint64_t> buckets_[20]{};
+};
+class HistogramCollector_80_10;
+class Histogram_80_10 {
+ public:
+  static int BucketFor(int value);
+  const uint64_t* buckets() const { return buckets_; }
+  friend Histogram_80_10 operator-(const Histogram_80_10& left,
+                                   const Histogram_80_10& right);
+
+ private:
+  friend class HistogramCollector_80_10;
+  uint64_t buckets_[10]{};
+};
+class HistogramCollector_80_10 {
+ public:
+  void Increment(int value) {
+    buckets_[Histogram_80_10::BucketFor(value)].fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void Collect(Histogram_80_10* result) const;
+
+ private:
+  std::atomic<uint64_t> buckets_[10]{};
+};
+struct GlobalStats {
+  enum class Counter {
+    kClientCallsCreated,
+    kServerCallsCreated,
+    kClientChannelsCreated,
+    kClientSubchannelsCreated,
+    kServerChannelsCreated,
+    kSyscallWrite,
+    kSyscallRead,
+    kTcpReadAlloc8k,
+    kTcpReadAlloc64k,
+    kHttp2SettingsWrites,
+    kHttp2PingsSent,
+    kHttp2WritesBegun,
+    kHttp2TransportStalls,
+    kHttp2StreamStalls,
+    kCqPluckCreates,
+    kCqNextCreates,
+    kCqCallbackCreates,
+    COUNT
+  };
+  enum class Histogram {
+    kCallInitialSize,
+    kTcpWriteSize,
+    kTcpWriteIovSize,
+    kTcpReadSize,
+    kTcpReadOffer,
+    kTcpReadOfferIovSize,
+    kHttp2SendMessageSize,
+    COUNT
+  };
+  GlobalStats();
+  static const absl::string_view counter_name[static_cast<int>(Counter::COUNT)];
+  static const absl::string_view
+      histogram_name[static_cast<int>(Histogram::COUNT)];
+  static const absl::string_view counter_doc[static_cast<int>(Counter::COUNT)];
+  static const absl::string_view
+      histogram_doc[static_cast<int>(Histogram::COUNT)];
+  union {
+    struct {
+      uint64_t client_calls_created;
+      uint64_t server_calls_created;
+      uint64_t client_channels_created;
+      uint64_t client_subchannels_created;
+      uint64_t server_channels_created;
+      uint64_t syscall_write;
+      uint64_t syscall_read;
+      uint64_t tcp_read_alloc_8k;
+      uint64_t tcp_read_alloc_64k;
+      uint64_t http2_settings_writes;
+      uint64_t http2_pings_sent;
+      uint64_t http2_writes_begun;
+      uint64_t http2_transport_stalls;
+      uint64_t http2_stream_stalls;
+      uint64_t cq_pluck_creates;
+      uint64_t cq_next_creates;
+      uint64_t cq_callback_creates;
+    };
+    uint64_t counters[static_cast<int>(Counter::COUNT)];
+  };
+  Histogram_32768_24 call_initial_size;
+  Histogram_16777216_20 tcp_write_size;
+  Histogram_80_10 tcp_write_iov_size;
+  Histogram_16777216_20 tcp_read_size;
+  Histogram_16777216_20 tcp_read_offer;
+  Histogram_80_10 tcp_read_offer_iov_size;
+  Histogram_16777216_20 http2_send_message_size;
+  HistogramView histogram(Histogram which) const;
+  std::unique_ptr<GlobalStats> Diff(const GlobalStats& other) const;
+};
+class GlobalStatsCollector {
+ public:
+  std::unique_ptr<GlobalStats> Collect() const;
+  void IncrementClientCallsCreated() {
+    data_.this_cpu().client_calls_created.fetch_add(1,
+                                                    std::memory_order_relaxed);
+  }
+  void IncrementServerCallsCreated() {
+    data_.this_cpu().server_calls_created.fetch_add(1,
+                                                    std::memory_order_relaxed);
+  }
+  void IncrementClientChannelsCreated() {
+    data_.this_cpu().client_channels_created.fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void IncrementClientSubchannelsCreated() {
+    data_.this_cpu().client_subchannels_created.fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void IncrementServerChannelsCreated() {
+    data_.this_cpu().server_channels_created.fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void IncrementSyscallWrite() {
+    data_.this_cpu().syscall_write.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementSyscallRead() {
+    data_.this_cpu().syscall_read.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementTcpReadAlloc8k() {
+    data_.this_cpu().tcp_read_alloc_8k.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementTcpReadAlloc64k() {
+    data_.this_cpu().tcp_read_alloc_64k.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementHttp2SettingsWrites() {
+    data_.this_cpu().http2_settings_writes.fetch_add(1,
+                                                     std::memory_order_relaxed);
+  }
+  void IncrementHttp2PingsSent() {
+    data_.this_cpu().http2_pings_sent.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementHttp2WritesBegun() {
+    data_.this_cpu().http2_writes_begun.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementHttp2TransportStalls() {
+    data_.this_cpu().http2_transport_stalls.fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void IncrementHttp2StreamStalls() {
+    data_.this_cpu().http2_stream_stalls.fetch_add(1,
+                                                   std::memory_order_relaxed);
+  }
+  void IncrementCqPluckCreates() {
+    data_.this_cpu().cq_pluck_creates.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementCqNextCreates() {
+    data_.this_cpu().cq_next_creates.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementCqCallbackCreates() {
+    data_.this_cpu().cq_callback_creates.fetch_add(1,
+                                                   std::memory_order_relaxed);
+  }
+  void IncrementCallInitialSize(int value) {
+    data_.this_cpu().call_initial_size.Increment(value);
+  }
+  void IncrementTcpWriteSize(int value) {
+    data_.this_cpu().tcp_write_size.Increment(value);
+  }
+  void IncrementTcpWriteIovSize(int value) {
+    data_.this_cpu().tcp_write_iov_size.Increment(value);
+  }
+  void IncrementTcpReadSize(int value) {
+    data_.this_cpu().tcp_read_size.Increment(value);
+  }
+  void IncrementTcpReadOffer(int value) {
+    data_.this_cpu().tcp_read_offer.Increment(value);
+  }
+  void IncrementTcpReadOfferIovSize(int value) {
+    data_.this_cpu().tcp_read_offer_iov_size.Increment(value);
+  }
+  void IncrementHttp2SendMessageSize(int value) {
+    data_.this_cpu().http2_send_message_size.Increment(value);
+  }
+
+ private:
+  struct Data {
+    std::atomic<uint64_t> client_calls_created{0};
+    std::atomic<uint64_t> server_calls_created{0};
+    std::atomic<uint64_t> client_channels_created{0};
+    std::atomic<uint64_t> client_subchannels_created{0};
+    std::atomic<uint64_t> server_channels_created{0};
+    std::atomic<uint64_t> syscall_write{0};
+    std::atomic<uint64_t> syscall_read{0};
+    std::atomic<uint64_t> tcp_read_alloc_8k{0};
+    std::atomic<uint64_t> tcp_read_alloc_64k{0};
+    std::atomic<uint64_t> http2_settings_writes{0};
+    std::atomic<uint64_t> http2_pings_sent{0};
+    std::atomic<uint64_t> http2_writes_begun{0};
+    std::atomic<uint64_t> http2_transport_stalls{0};
+    std::atomic<uint64_t> http2_stream_stalls{0};
+    std::atomic<uint64_t> cq_pluck_creates{0};
+    std::atomic<uint64_t> cq_next_creates{0};
+    std::atomic<uint64_t> cq_callback_creates{0};
+    HistogramCollector_32768_24 call_initial_size;
+    HistogramCollector_16777216_20 tcp_write_size;
+    HistogramCollector_80_10 tcp_write_iov_size;
+    HistogramCollector_16777216_20 tcp_read_size;
+    HistogramCollector_16777216_20 tcp_read_offer;
+    HistogramCollector_80_10 tcp_read_offer_iov_size;
+    HistogramCollector_16777216_20 http2_send_message_size;
+  };
+  PerCpu<Data> data_;
+};
 }  // namespace grpc_core
-extern const int grpc_stats_histo_buckets[7];
-extern const int grpc_stats_histo_start[7];
-extern const int* const grpc_stats_histo_bucket_boundaries[7];
-extern int (*const grpc_stats_get_bucket[7])(int value);
 
 #endif /* GRPC_CORE_LIB_DEBUG_STATS_DATA_H */

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

@@ -0,0 +1,71 @@
+// 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_COMMON_CLOSURES_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_COMMON_CLOSURES_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class AnyInvocableClosure : public EventEngine::Closure {
+ public:
+  explicit AnyInvocableClosure(absl::AnyInvocable<void()> cb)
+      : cb_(std::move(cb)) {}
+  void Run() override { cb_(); }
+
+ private:
+  absl::AnyInvocable<void()> cb_;
+};
+
+class SelfDeletingClosure : public EventEngine::Closure {
+ public:
+  // Creates a SelfDeletingClosure.
+  // The closure will be deleted after Run is called.
+  static Closure* Create(absl::AnyInvocable<void()> cb) {
+    return new SelfDeletingClosure(std::move(cb), nullptr);
+  }
+  // Creates a SelfDeletingClosure with a custom destructor.
+  static Closure* Create(absl::AnyInvocable<void()> cb,
+                         absl::AnyInvocable<void()> dest_cb) {
+    return new SelfDeletingClosure(std::move(cb), std::move(dest_cb));
+  }
+  ~SelfDeletingClosure() override {
+    if (dest_cb_) dest_cb_();
+  };
+
+  void Run() override {
+    cb_();
+    delete this;
+  }
+
+ private:
+  explicit SelfDeletingClosure(absl::AnyInvocable<void()> cb,
+                               absl::AnyInvocable<void()> dest_cb)
+      : cb_(std::move(cb)), dest_cb_(std::move(dest_cb)) {}
+  absl::AnyInvocable<void()> cb_;
+  absl::AnyInvocable<void()> dest_cb_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_COMMON_CLOSURES_H

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

@@ -23,7 +23,13 @@
 
 #include <grpc/event_engine/event_engine.h>
 
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/default_event_engine_factory.h"
+#include "src/core/lib/event_engine/trace.h"
+#include "src/core/lib/gprpp/no_destruct.h"
+#include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -31,14 +37,23 @@ namespace experimental {
 namespace {
 std::atomic<absl::AnyInvocable<std::unique_ptr<EventEngine>()>*>
     g_event_engine_factory{nullptr};
-std::atomic<EventEngine*> g_event_engine{nullptr};
+grpc_core::NoDestruct<grpc_core::Mutex> g_mu;
+grpc_core::NoDestruct<std::weak_ptr<EventEngine>> g_event_engine;
 }  // namespace
 
-void SetDefaultEventEngineFactory(
+void SetEventEngineFactory(
     absl::AnyInvocable<std::unique_ptr<EventEngine>()> factory) {
   delete g_event_engine_factory.exchange(
       new absl::AnyInvocable<std::unique_ptr<EventEngine>()>(
           std::move(factory)));
+  // Forget any previous EventEngines
+  grpc_core::MutexLock lock(&*g_mu);
+  g_event_engine->reset();
+}
+
+void EventEngineFactoryReset() {
+  delete g_event_engine_factory.exchange(nullptr);
+  g_event_engine->reset();
 }
 
 std::unique_ptr<EventEngine> CreateEventEngine() {
@@ -48,23 +63,31 @@ std::unique_ptr<EventEngine> CreateEventEngine() {
   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;
-    }
+std::shared_ptr<EventEngine> GetDefaultEventEngine() {
+  grpc_core::MutexLock lock(&*g_mu);
+  if (std::shared_ptr<EventEngine> engine = g_event_engine->lock()) {
+    GRPC_EVENT_ENGINE_TRACE("DefaultEventEngine::%p use_count:%ld",
+                            engine.get(), engine.use_count());
+    return engine;
   }
+  std::shared_ptr<EventEngine> engine{CreateEventEngine()};
+  GRPC_EVENT_ENGINE_TRACE("Created DefaultEventEngine::%p", engine.get());
+  *g_event_engine = engine;
   return engine;
 }
 
-void ResetDefaultEventEngine() {
-  delete g_event_engine.exchange(nullptr, std::memory_order_acq_rel);
+namespace {
+grpc_core::ChannelArgs EnsureEventEngineInChannelArgs(
+    grpc_core::ChannelArgs args) {
+  if (args.ContainsObject<EventEngine>()) return args;
+  return args.SetObject<EventEngine>(GetDefaultEventEngine());
+}
+}  // namespace
+
+void RegisterEventEngineChannelArgPreconditioning(
+    grpc_core::CoreConfiguration::Builder* builder) {
+  builder->channel_args_preconditioning()->RegisterStage(
+      grpc_event_engine::experimental::EnsureEventEngineInChannelArgs);
 }
 
 }  // namespace experimental

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

@@ -17,8 +17,18 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
 #include <grpc/event_engine/event_engine.h>
 
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/promise/context.h"
+
+namespace grpc_core {
+template <>
+struct ContextType<grpc_event_engine::experimental::EventEngine> {};
+}  // namespace grpc_core
+
 namespace grpc_event_engine {
 namespace experimental {
 
@@ -26,10 +36,12 @@ namespace experimental {
 ///
 /// The concept of a global EventEngine may go away in a post-iomgr world.
 /// Strongly consider whether you could use \a CreateEventEngine instead.
-EventEngine* GetDefaultEventEngine();
+std::shared_ptr<EventEngine> GetDefaultEventEngine();
 
-/// Reset the default event engine
-void ResetDefaultEventEngine();
+/// On ingress, ensure that an EventEngine exists in channel args via
+/// preconditioning.
+void RegisterEventEngineChannelArgPreconditioning(
+    grpc_core::CoreConfiguration::Builder* builder);
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -18,8 +18,6 @@
 
 #include <memory>
 
-#include "absl/memory/memory.h"
-
 #include <grpc/event_engine/event_engine.h>
 
 #ifdef GPR_WINDOWS
@@ -29,7 +27,7 @@ namespace grpc_event_engine {
 namespace experimental {
 
 std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
-  return absl::make_unique<WindowsEventEngine>();
+  return std::make_unique<WindowsEventEngine>();
 }
 
 }  // namespace experimental
@@ -41,7 +39,7 @@ namespace grpc_event_engine {
 namespace experimental {
 
 std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
-  return absl::make_unique<PosixEventEngine>();
+  return std::make_unique<PosixEventEngine>();
 }
 
 }  // namespace experimental

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

@@ -25,7 +25,7 @@
 #include <grpc/event_engine/memory_request.h>
 #include <grpc/slice.h>
 
-#include "src/core/lib/slice/slice_refcount_base.h"
+#include "src/core/lib/slice/slice_refcount.h"
 
 namespace grpc_event_engine {
 namespace experimental {

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

@@ -40,10 +40,16 @@ class Poller {
   // polling.
   //
   // Returns:
-  //  * Poller::WorkResult::kKicked if it was Kicked.
-  //  * Poller::WorkResult::kDeadlineExceeded if timeout occurred
-  //  * Poller::WorkResult::kOk, otherwise indicating that the callback function
-  //  was run synchonously before some events were processed.
+  //  * Poller::WorkResult::kKicked if it was Kicked. A poller that was Kicked
+  //  may still process some events and if so, it may have run the
+  //  schedule_poll_again callback function synchronously. When the poller
+  //  returns Poller::WorkResult::kKicked tts upto the user to determine
+  //  if the schedule_poll_again callback has run or not.
+  //  * Poller::WorkResult::kDeadlineExceeded if timeout occurred. The
+  //  schedule_poll_again callback is not run in this case.
+  //  * Poller::WorkResult::kOk, otherwise indicating that the
+  //  schedule_poll_again callback function was run synchonously before some
+  //  events were processed.
   virtual WorkResult Work(EventEngine::Duration timeout,
                           absl::FunctionRef<void()> schedule_poll_again) = 0;
   // Trigger the threads executing Work(..) to break out as soon as possible.