grpc 1.42.0 → 1.46.3

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

@@ -19,7 +19,11 @@
 
 #include <atomic>
 
+#include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/resolver/resolver_registry.h"
+#include "src/core/lib/security/credentials/channel_creds_registry.h"
+#include "src/core/lib/service_config/service_config_parser.h"
 #include "src/core/lib/surface/channel_init.h"
 
 namespace grpc_core {
@@ -35,17 +39,37 @@ class CoreConfiguration {
   // their configuration and assemble the published CoreConfiguration.
   class Builder {
    public:
+    ChannelArgsPreconditioning::Builder* channel_args_preconditioning() {
+      return &channel_args_preconditioning_;
+    }
+
     ChannelInit::Builder* channel_init() { return &channel_init_; }
 
     HandshakerRegistry::Builder* handshaker_registry() {
       return &handshaker_registry_;
     }
 
+    ChannelCredsRegistry<>::Builder* channel_creds_registry() {
+      return &channel_creds_registry_;
+    }
+
+    ServiceConfigParser::Builder* service_config_parser() {
+      return &service_config_parser_;
+    }
+
+    ResolverRegistry::Builder* resolver_registry() {
+      return &resolver_registry_;
+    }
+
    private:
     friend class CoreConfiguration;
 
+    ChannelArgsPreconditioning::Builder channel_args_preconditioning_;
     ChannelInit::Builder channel_init_;
     HandshakerRegistry::Builder handshaker_registry_;
+    ChannelCredsRegistry<>::Builder channel_creds_registry_;
+    ServiceConfigParser::Builder service_config_parser_;
+    ResolverRegistry::Builder resolver_registry_;
 
     Builder();
     CoreConfiguration* Build();
@@ -111,12 +135,32 @@ class CoreConfiguration {
 
   // Accessors
 
+  const ChannelArgsPreconditioning& channel_args_preconditioning() const {
+    return channel_args_preconditioning_;
+  }
+
   const ChannelInit& channel_init() const { return channel_init_; }
 
   const HandshakerRegistry& handshaker_registry() const {
     return handshaker_registry_;
   }
 
+  const ChannelCredsRegistry<>& channel_creds_registry() const {
+    return channel_creds_registry_;
+  }
+
+  const ServiceConfigParser& service_config_parser() const {
+    return service_config_parser_;
+  }
+
+  const ResolverRegistry& resolver_registry() const {
+    return resolver_registry_;
+  }
+
+  static void SetDefaultBuilder(void (*builder)(CoreConfiguration::Builder*)) {
+    default_builder_ = builder;
+  }
+
  private:
   explicit CoreConfiguration(Builder* builder);
 
@@ -134,9 +178,15 @@ class CoreConfiguration {
   static std::atomic<CoreConfiguration*> config_;
   // Extra registered builders
   static std::atomic<RegisteredBuilder*> builders_;
+  // Default builder
+  static void (*default_builder_)(CoreConfiguration::Builder*);
 
+  ChannelArgsPreconditioning channel_args_preconditioning_;
   ChannelInit channel_init_;
   HandshakerRegistry handshaker_registry_;
+  ChannelCredsRegistry<> channel_creds_registry_;
+  ServiceConfigParser service_config_parser_;
+  ResolverRegistry resolver_registry_;
 };
 
 extern void BuildCoreConfiguration(CoreConfiguration::Builder* builder);

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

@@ -41,8 +41,6 @@ const char* grpc_stats_counter_name[GRPC_STATS_COUNTER_COUNT] = {
     "pollset_kick_wakeup_fd",
     "pollset_kick_wakeup_cv",
     "pollset_kick_own_thread",
-    "syscall_epoll_ctl",
-    "pollset_fd_cache_hits",
     "histogram_slow_lookups",
     "syscall_write",
     "syscall_read",
@@ -75,6 +73,7 @@ const char* grpc_stats_counter_name[GRPC_STATS_COUNTER_COUNT] = {
     "http2_initiate_write_due_to_stream_flow_control",
     "http2_initiate_write_due_to_transport_flow_control",
     "http2_initiate_write_due_to_send_settings",
+    "http2_initiate_write_due_to_settings_ack",
     "http2_initiate_write_due_to_bdp_estimator_ping",
     "http2_initiate_write_due_to_flow_control_unstalled_by_setting",
     "http2_initiate_write_due_to_flow_control_unstalled_by_update",
@@ -147,9 +146,6 @@ const char* grpc_stats_counter_doc[GRPC_STATS_COUNTER_COUNT] = {
     "polling wakeup (only valid for epoll1 right now)",
     "How many times could a polling wakeup be satisfied by keeping the waking "
     "thread awake? (only valid for epoll1 right now)",
-    "Number of epoll_ctl calls made (only valid for epollex right now)",
-    "Number of epoll_ctl calls skipped because the fd was cached as already "
-    "being added.  (only valid for epollex right now)",
     "Number of times histogram increments went through the slow (binary "
     "search) path",
     "Number of write syscalls (or equivalent - eg sendmsg) made by this "
@@ -186,6 +182,7 @@ const char* grpc_stats_counter_doc[GRPC_STATS_COUNTER_COUNT] = {
     "Number of HTTP2 writes initiated due to 'stream_flow_control'",
     "Number of HTTP2 writes initiated due to 'transport_flow_control'",
     "Number of HTTP2 writes initiated due to 'send_settings'",
+    "Number of HTTP2 writes initiated due to 'settings_ack'",
     "Number of HTTP2 writes initiated due to 'bdp_estimator_ping'",
     "Number of HTTP2 writes initiated due to "
     "'flow_control_unstalled_by_setting'",
@@ -281,7 +278,6 @@ const char* grpc_stats_histogram_doc[GRPC_STATS_HISTOGRAM_COUNT] = {
     "Number of streams whose payload was written per TCP write",
     "Number of streams terminated per TCP write",
     "Number of flow control updates written per TCP write",
-    // NOLINTNEXTLINE(bugprone-suspicious-missing-comma)
     "How many completion queues were checked looking for a CQ that had "
     "requested the incoming call",
 };

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

@@ -42,8 +42,6 @@ typedef enum {
   GRPC_STATS_COUNTER_POLLSET_KICK_WAKEUP_FD,
   GRPC_STATS_COUNTER_POLLSET_KICK_WAKEUP_CV,
   GRPC_STATS_COUNTER_POLLSET_KICK_OWN_THREAD,
-  GRPC_STATS_COUNTER_SYSCALL_EPOLL_CTL,
-  GRPC_STATS_COUNTER_POLLSET_FD_CACHE_HITS,
   GRPC_STATS_COUNTER_HISTOGRAM_SLOW_LOOKUPS,
   GRPC_STATS_COUNTER_SYSCALL_WRITE,
   GRPC_STATS_COUNTER_SYSCALL_READ,
@@ -76,6 +74,7 @@ typedef enum {
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_STREAM_FLOW_CONTROL,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_TRANSPORT_FLOW_CONTROL,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_SEND_SETTINGS,
+  GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_SETTINGS_ACK,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_BDP_ESTIMATOR_PING,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_FLOW_CONTROL_UNSTALLED_BY_SETTING,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_FLOW_CONTROL_UNSTALLED_BY_UPDATE,
@@ -206,10 +205,6 @@ typedef enum {
   GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_POLLSET_KICK_WAKEUP_CV)
 #define GRPC_STATS_INC_POLLSET_KICK_OWN_THREAD() \
   GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_POLLSET_KICK_OWN_THREAD)
-#define GRPC_STATS_INC_SYSCALL_EPOLL_CTL() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_SYSCALL_EPOLL_CTL)
-#define GRPC_STATS_INC_POLLSET_FD_CACHE_HITS() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_POLLSET_FD_CACHE_HITS)
 #define GRPC_STATS_INC_HISTOGRAM_SLOW_LOOKUPS() \
   GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_HISTOGRAM_SLOW_LOOKUPS)
 #define GRPC_STATS_INC_SYSCALL_WRITE() \
@@ -287,6 +282,9 @@ typedef enum {
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_SEND_SETTINGS() \
   GRPC_STATS_INC_COUNTER(                                          \
       GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_SEND_SETTINGS)
+#define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_SETTINGS_ACK() \
+  GRPC_STATS_INC_COUNTER(                                         \
+      GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_SETTINGS_ACK)
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_BDP_ESTIMATOR_PING() \
   GRPC_STATS_INC_COUNTER(                                               \
       GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_BDP_ESTIMATOR_PING)
@@ -398,43 +396,43 @@ typedef enum {
   GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_CQ_EV_QUEUE_TRANSIENT_POP_FAILURES)
 #define GRPC_STATS_INC_CALL_INITIAL_SIZE(value) \
   grpc_stats_inc_call_initial_size((int)(value))
-void grpc_stats_inc_call_initial_size(int value);
+void grpc_stats_inc_call_initial_size(int x);
 #define GRPC_STATS_INC_POLL_EVENTS_RETURNED(value) \
   grpc_stats_inc_poll_events_returned((int)(value))
-void grpc_stats_inc_poll_events_returned(int value);
+void grpc_stats_inc_poll_events_returned(int x);
 #define GRPC_STATS_INC_TCP_WRITE_SIZE(value) \
   grpc_stats_inc_tcp_write_size((int)(value))
-void grpc_stats_inc_tcp_write_size(int value);
+void grpc_stats_inc_tcp_write_size(int x);
 #define GRPC_STATS_INC_TCP_WRITE_IOV_SIZE(value) \
   grpc_stats_inc_tcp_write_iov_size((int)(value))
-void grpc_stats_inc_tcp_write_iov_size(int value);
+void grpc_stats_inc_tcp_write_iov_size(int x);
 #define GRPC_STATS_INC_TCP_READ_SIZE(value) \
   grpc_stats_inc_tcp_read_size((int)(value))
-void grpc_stats_inc_tcp_read_size(int value);
+void grpc_stats_inc_tcp_read_size(int x);
 #define GRPC_STATS_INC_TCP_READ_OFFER(value) \
   grpc_stats_inc_tcp_read_offer((int)(value))
-void grpc_stats_inc_tcp_read_offer(int value);
+void grpc_stats_inc_tcp_read_offer(int x);
 #define GRPC_STATS_INC_TCP_READ_OFFER_IOV_SIZE(value) \
   grpc_stats_inc_tcp_read_offer_iov_size((int)(value))
-void grpc_stats_inc_tcp_read_offer_iov_size(int value);
+void grpc_stats_inc_tcp_read_offer_iov_size(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_MESSAGE_SIZE(value) \
   grpc_stats_inc_http2_send_message_size((int)(value))
-void grpc_stats_inc_http2_send_message_size(int value);
+void grpc_stats_inc_http2_send_message_size(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_INITIAL_METADATA_PER_WRITE(value) \
   grpc_stats_inc_http2_send_initial_metadata_per_write((int)(value))
-void grpc_stats_inc_http2_send_initial_metadata_per_write(int value);
+void grpc_stats_inc_http2_send_initial_metadata_per_write(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_MESSAGE_PER_WRITE(value) \
   grpc_stats_inc_http2_send_message_per_write((int)(value))
-void grpc_stats_inc_http2_send_message_per_write(int value);
+void grpc_stats_inc_http2_send_message_per_write(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_TRAILING_METADATA_PER_WRITE(value) \
   grpc_stats_inc_http2_send_trailing_metadata_per_write((int)(value))
-void grpc_stats_inc_http2_send_trailing_metadata_per_write(int value);
+void grpc_stats_inc_http2_send_trailing_metadata_per_write(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_FLOWCTL_PER_WRITE(value) \
   grpc_stats_inc_http2_send_flowctl_per_write((int)(value))
-void grpc_stats_inc_http2_send_flowctl_per_write(int value);
+void grpc_stats_inc_http2_send_flowctl_per_write(int x);
 #define GRPC_STATS_INC_SERVER_CQS_CHECKED(value) \
   grpc_stats_inc_server_cqs_checked((int)(value))
-void grpc_stats_inc_server_cqs_checked(int value);
+void grpc_stats_inc_server_cqs_checked(int x);
 #else
 #define GRPC_STATS_INC_CLIENT_CALLS_CREATED()
 #define GRPC_STATS_INC_SERVER_CALLS_CREATED()
@@ -450,8 +448,6 @@ void grpc_stats_inc_server_cqs_checked(int value);
 #define GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD()
 #define GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV()
 #define GRPC_STATS_INC_POLLSET_KICK_OWN_THREAD()
-#define GRPC_STATS_INC_SYSCALL_EPOLL_CTL()
-#define GRPC_STATS_INC_POLLSET_FD_CACHE_HITS()
 #define GRPC_STATS_INC_HISTOGRAM_SLOW_LOOKUPS()
 #define GRPC_STATS_INC_SYSCALL_WRITE()
 #define GRPC_STATS_INC_SYSCALL_READ()
@@ -484,6 +480,7 @@ void grpc_stats_inc_server_cqs_checked(int value);
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_STREAM_FLOW_CONTROL()
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_TRANSPORT_FLOW_CONTROL()
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_SEND_SETTINGS()
+#define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_SETTINGS_ACK()
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_BDP_ESTIMATOR_PING()
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_FLOW_CONTROL_UNSTALLED_BY_SETTING()
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_FLOW_CONTROL_UNSTALLED_BY_UPDATE()

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

@@ -56,7 +56,7 @@ class TraceFlagList {
 };
 
 namespace testing {
-void grpc_tracer_enable_flag(grpc_core::TraceFlag* flag);
+void grpc_tracer_enable_flag(TraceFlag* flag);
 }
 
 class TraceFlag {
@@ -90,7 +90,7 @@ class TraceFlag {
 #endif /* defined(GRPC_USE_TRACERS) || !defined(NDEBUG) */
 
  private:
-  friend void grpc_core::testing::grpc_tracer_enable_flag(TraceFlag* flag);
+  friend void testing::grpc_tracer_enable_flag(TraceFlag* flag);
   friend class TraceFlagList;
 
   void set_enabled(bool enabled) {

data/src/core/lib/event_engine/{endpoint_config.cc → channel_args_endpoint_config.cc}

@@ -13,12 +13,13 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/impl/codegen/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/event_engine/endpoint_config_internal.h"
 #include "src/core/lib/gpr/useful.h"
 
 namespace grpc_event_engine {

data/src/core/lib/event_engine/{endpoint_config_internal.h → channel_args_endpoint_config.h}

@@ -11,8 +11,8 @@
 // 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_ENDPOINT_CONFIG_INTERNAL_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_ENDPOINT_CONFIG_INTERNAL_H
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_CHANNEL_ARGS_ENDPOINT_CONFIG_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_CHANNEL_ARGS_ENDPOINT_CONFIG_H
 
 #include <grpc/support/port_platform.h>
 
@@ -39,4 +39,4 @@ class ChannelArgsEndpointConfig : public EndpointConfig {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_ENDPOINT_CONFIG_INTERNAL_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_CHANNEL_ARGS_ENDPOINT_CONFIG_H

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

@@ -0,0 +1,27 @@
+// 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 "src/core/lib/event_engine/event_engine_factory.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
+  // TODO(hork): call LibuvEventEngineFactory
+  return nullptr;
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

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

@@ -13,37 +13,39 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
-
-#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/port.h>
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/event_engine/sockaddr.h"
+#include "src/core/lib/event_engine/event_engine_factory.h"
+#include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
-                                              socklen_t size)
-    : size_(size) {
-  GPR_ASSERT(size <= sizeof(address_));
-  memcpy(&address_, address, size);
-}
+namespace {
+const std::function<std::unique_ptr<EventEngine>()>* g_event_engine_factory =
+    nullptr;
+grpc_core::Mutex* g_mu = new grpc_core::Mutex();
+}  // namespace
 
-const struct sockaddr* EventEngine::ResolvedAddress::address() const {
-  return reinterpret_cast<const struct sockaddr*>(address_);
+void SetDefaultEventEngineFactory(
+    const std::function<std::unique_ptr<EventEngine>()>* factory) {
+  grpc_core::MutexLock lock(g_mu);
+  g_event_engine_factory = factory;
 }
 
-socklen_t EventEngine::ResolvedAddress::size() const { return size_; }
+std::unique_ptr<EventEngine> CreateEventEngine() {
+  grpc_core::MutexLock lock(g_mu);
+  if (g_event_engine_factory != nullptr) {
+    return (*g_event_engine_factory)();
+  }
+  return DefaultEventEngineFactory();
+}
 
-std::shared_ptr<grpc_event_engine::experimental::EventEngine>
-DefaultEventEngineFactory() {
-  // TODO(nnoble): delete when uv-ee is merged
-  abort();
+EventEngine* GetDefaultEventEngine() {
+  static EventEngine* default_event_engine = CreateEventEngine().release();
+  return default_event_engine;
 }
 
 }  // namespace experimental

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

@@ -0,0 +1,36 @@
+// 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_EVENT_ENGINE_FACTORY_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// Access the shared global EventEngine instance.
+///
+/// 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();
+
+/// 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_EVENT_ENGINE_FACTORY_H

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

@@ -0,0 +1,66 @@
+// Copyright 2021 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 <grpc/event_engine/memory_allocator.h>
+
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/slice/slice_refcount.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+
+// Reference count for a slice allocated by MemoryAllocator::MakeSlice.
+// Takes care of releasing memory back when the slice is destroyed.
+class SliceRefCount : public grpc_slice_refcount {
+ public:
+  SliceRefCount(std::shared_ptr<internal::MemoryAllocatorImpl> allocator,
+                size_t size)
+      : grpc_slice_refcount(Destroy),
+        allocator_(std::move(allocator)),
+        size_(size) {
+    // Nothing to do here.
+  }
+  ~SliceRefCount() { allocator_->Release(size_); }
+
+ private:
+  static void Destroy(grpc_slice_refcount* p) {
+    auto* rc = static_cast<SliceRefCount*>(p);
+    rc->~SliceRefCount();
+    gpr_free(rc);
+  }
+
+  std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
+  size_t size_;
+};
+
+}  // namespace
+
+grpc_slice MemoryAllocator::MakeSlice(MemoryRequest request) {
+  auto size = Reserve(request.Increase(sizeof(SliceRefCount)));
+  void* p = gpr_malloc(size);
+  new (p) SliceRefCount(allocator_, size);
+  grpc_slice slice;
+  slice.refcount = static_cast<SliceRefCount*>(p);
+  slice.data.refcounted.bytes =
+      static_cast<uint8_t*>(p) + sizeof(SliceRefCount);
+  slice.data.refcounted.length = size - sizeof(SliceRefCount);
+  return slice;
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,39 @@
+// 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 <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/port.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
+                                              socklen_t size)
+    : size_(size) {
+  GPR_ASSERT(size <= sizeof(address_));
+  memcpy(&address_, address, size);
+}
+
+const struct sockaddr* EventEngine::ResolvedAddress::address() const {
+  return reinterpret_cast<const struct sockaddr*>(address_);
+}
+
+socklen_t EventEngine::ResolvedAddress::size() const { return size_; }
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/gpr/sync_posix.cc

@@ -131,6 +131,7 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
     abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_MONOTONIC);
 #else
     abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME);
+    abs_deadline = gpr_time_max(abs_deadline, gpr_now(abs_deadline.clock_type));
 #endif  // GPR_LINUX
     abs_deadline_ts.tv_sec = static_cast<time_t>(abs_deadline.tv_sec);
     abs_deadline_ts.tv_nsec = abs_deadline.tv_nsec;

data/src/core/lib/gpr/time.cc

@@ -184,7 +184,8 @@ gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b) {
     dec++;
   }
   if (a.tv_sec == INT64_MAX || a.tv_sec == INT64_MIN) {
-    diff = a;
+    diff.tv_sec = a.tv_sec;
+    diff.tv_nsec = a.tv_nsec;
   } else if (b.tv_sec == INT64_MIN ||
              (b.tv_sec <= 0 && a.tv_sec >= INT64_MAX + b.tv_sec)) {
     diff = gpr_inf_future(GPR_CLOCK_REALTIME);

data/src/core/lib/gpr/tls.h

@@ -50,6 +50,7 @@ class TlsTypeConstrainer {
 
 #include <pthread.h>
 
+#include <algorithm>
 #include <array>
 #include <cstring>
 
@@ -118,6 +119,12 @@ class PthreadTlsImpl : TlsTypeConstrainer<T> {
     return t;
   }
 
+  T operator->() const {
+    static_assert(std::is_pointer<T>::value,
+                  "operator-> only usable on pointers");
+    return this->operator T();
+  }
+
   T operator=(T t) {
     char* src = reinterpret_cast<char*>(&t);
     for (pthread_key_t key : keys_) {

data/src/core/lib/gpr/useful.h

@@ -106,6 +106,24 @@ constexpr size_t HashPointer(T* p, size_t range) {
          range;
 }
 
+// Compute a+b.
+// If the result is greater than INT64_MAX, return INT64_MAX.
+// If the result is less than INT64_MIN, return INT64_MIN.
+inline int64_t SaturatingAdd(int64_t a, int64_t b) {
+  if (a > 0) {
+    if (b > INT64_MAX - a) {
+      return INT64_MAX;
+    }
+  } else if (b < INT64_MIN - a) {
+    return INT64_MIN;
+  }
+  return a + b;
+}
+
+inline uint32_t MixHash32(uint32_t a, uint32_t b) {
+  return RotateLeft(a, 2u) ^ b;
+}
+
 }  // namespace grpc_core
 
 #define GPR_ARRAY_SIZE(array) (sizeof(array) / sizeof(*(array)))

data/src/core/lib/gprpp/bitset.h

@@ -146,6 +146,25 @@ class BitSet {
     return count;
   }
 
+  bool operator==(const BitSet& other) const {
+    for (size_t i = 0; i < kUnits; i++) {
+      if (units_[i] != other.units_[i]) return false;
+    }
+    return true;
+  }
+
+  template <typename Int>
+  typename std::enable_if<std::is_unsigned<Int>::value &&
+                              (sizeof(Int) * 8 >= kTotalBits),
+                          Int>::type
+  ToInt() const {
+    Int result = 0;
+    for (size_t i = 0; i < kTotalBits; i++) {
+      if (is_set(i)) result |= (Int(1) << i);
+    }
+    return result;
+  }
+
  private:
   // Given a bit index, return which unit it's stored in.
   static constexpr size_t unit_for(size_t bit) { return bit / kUnitBits; }