grpc 1.37.1 → 1.39.0

data/src/core/lib/iomgr/ev_posix.cc

@@ -270,7 +270,7 @@ void grpc_fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
   g_event_engine->fd_orphan(fd, on_done, release_fd, reason);
 }
 
-void grpc_fd_shutdown(grpc_fd* fd, grpc_error* why) {
+void grpc_fd_shutdown(grpc_fd* fd, grpc_error_handle why) {
   GRPC_POLLING_API_TRACE("fd_shutdown(%d)", grpc_fd_wrapped_fd(fd));
   GRPC_FD_TRACE("fd_shutdown(%d)", grpc_fd_wrapped_fd(fd));
   g_event_engine->fd_shutdown(fd, why);
@@ -315,19 +315,20 @@ static void pollset_destroy(grpc_pollset* pollset) {
   g_event_engine->pollset_destroy(pollset);
 }
 
-static grpc_error* pollset_work(grpc_pollset* pollset,
-                                grpc_pollset_worker** worker,
-                                grpc_millis deadline) {
+static grpc_error_handle pollset_work(grpc_pollset* pollset,
+                                      grpc_pollset_worker** worker,
+                                      grpc_millis deadline) {
   GRPC_POLLING_API_TRACE("pollset_work(%p, %" PRId64 ") begin", pollset,
                          deadline);
-  grpc_error* err = g_event_engine->pollset_work(pollset, worker, deadline);
+  grpc_error_handle err =
+      g_event_engine->pollset_work(pollset, worker, deadline);
   GRPC_POLLING_API_TRACE("pollset_work(%p, %" PRId64 ") end", pollset,
                          deadline);
   return err;
 }
 
-static grpc_error* pollset_kick(grpc_pollset* pollset,
-                                grpc_pollset_worker* specific_worker) {
+static grpc_error_handle pollset_kick(grpc_pollset* pollset,
+                                      grpc_pollset_worker* specific_worker) {
   GRPC_POLLING_API_TRACE("pollset_kick(%p, %p)", pollset, specific_worker);
   return g_event_engine->pollset_kick(pollset, specific_worker);
 }
@@ -406,7 +407,7 @@ bool grpc_is_any_background_poller_thread(void) {
 }
 
 bool grpc_add_closure_to_background_poller(grpc_closure* closure,
-                                           grpc_error* error) {
+                                           grpc_error_handle error) {
   return g_event_engine->add_closure_to_background_poller(closure, error);
 }
 

data/src/core/lib/iomgr/ev_posix.h

@@ -52,7 +52,7 @@ typedef struct grpc_event_engine_vtable {
   int (*fd_wrapped_fd)(grpc_fd* fd);
   void (*fd_orphan)(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
                     const char* reason);
-  void (*fd_shutdown)(grpc_fd* fd, grpc_error* why);
+  void (*fd_shutdown)(grpc_fd* fd, grpc_error_handle why);
   void (*fd_notify_on_read)(grpc_fd* fd, grpc_closure* closure);
   void (*fd_notify_on_write)(grpc_fd* fd, grpc_closure* closure);
   void (*fd_notify_on_error)(grpc_fd* fd, grpc_closure* closure);
@@ -64,11 +64,11 @@ typedef struct grpc_event_engine_vtable {
   void (*pollset_init)(grpc_pollset* pollset, gpr_mu** mu);
   void (*pollset_shutdown)(grpc_pollset* pollset, grpc_closure* closure);
   void (*pollset_destroy)(grpc_pollset* pollset);
-  grpc_error* (*pollset_work)(grpc_pollset* pollset,
-                              grpc_pollset_worker** worker,
-                              grpc_millis deadline);
-  grpc_error* (*pollset_kick)(grpc_pollset* pollset,
-                              grpc_pollset_worker* specific_worker);
+  grpc_error_handle (*pollset_work)(grpc_pollset* pollset,
+                                    grpc_pollset_worker** worker,
+                                    grpc_millis deadline);
+  grpc_error_handle (*pollset_kick)(grpc_pollset* pollset,
+                                    grpc_pollset_worker* specific_worker);
   void (*pollset_add_fd)(grpc_pollset* pollset, struct grpc_fd* fd);
 
   grpc_pollset_set* (*pollset_set_create)(void);
@@ -88,7 +88,7 @@ typedef struct grpc_event_engine_vtable {
   void (*shutdown_background_closure)(void);
   void (*shutdown_engine)(void);
   bool (*add_closure_to_background_poller)(grpc_closure* closure,
-                                           grpc_error* error);
+                                           grpc_error_handle error);
 } grpc_event_engine_vtable;
 
 /* register a new event engine factory */
@@ -139,7 +139,7 @@ void grpc_fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
 bool grpc_fd_is_shutdown(grpc_fd* fd);
 
 /* Cause any current and future callbacks to fail. */
-void grpc_fd_shutdown(grpc_fd* fd, grpc_error* why);
+void grpc_fd_shutdown(grpc_fd* fd, grpc_error_handle why);
 
 /* Register read interest, causing read_cb to be called once when fd becomes
    readable, on deadline specified by deadline, or on shutdown triggered by
@@ -195,7 +195,7 @@ bool grpc_is_any_background_poller_thread();
  * that the closure may or may not run yet when this function returns, and the
  * closure should not be blocking or long-running. */
 bool grpc_add_closure_to_background_poller(grpc_closure* closure,
-                                           grpc_error* error);
+                                           grpc_error_handle error);
 
 /* Shut down all the closures registered in the background poller. */
 void grpc_shutdown_background_closure();

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

@@ -0,0 +1,54 @@
+// 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>
+
+#ifdef GRPC_USE_EVENT_ENGINE
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/event_engine/pollset.h"
+#include "src/core/lib/transport/error_utils.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+EventEngine::Callback GrpcClosureToCallback(grpc_closure* closure,
+                                            grpc_error_handle error) {
+  return [closure, error](absl::Status status) {
+    grpc_error_handle new_error =
+        grpc_error_add_child(error, absl_status_to_grpc_error(status));
+#ifndef NDEBUG
+    closure->scheduled = false;
+    if (grpc_trace_closure.enabled()) {
+      gpr_log(GPR_DEBUG,
+              "EventEngine: running closure %p: created [%s:%d]: %s [%s:%d]",
+              closure, closure->file_created, closure->line_created,
+              closure->run ? "run" : "scheduled", closure->file_initiated,
+              closure->line_initiated);
+    }
+#endif
+    closure->cb(closure->cb_arg, new_error);
+#ifndef NDEBUG
+    if (grpc_trace_closure.enabled()) {
+      gpr_log(GPR_DEBUG, "EventEngine: closure %p finished", closure);
+    }
+#endif
+    GRPC_ERROR_UNREF(error);
+    grpc_pollset_ee_broadcast_event();
+  };
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+#endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/iomgr/event_engine/closure.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_IOMGR_EVENT_ENGINE_CLOSURE_H
+#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_CLOSURE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+EventEngine::Callback GrpcClosureToCallback(grpc_closure* closure,
+                                            grpc_error_handle error);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_CLOSURE_H

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

@@ -0,0 +1,194 @@
+// 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>
+
+#ifdef GRPC_USE_EVENT_ENGINE
+#include "src/core/lib/iomgr/event_engine/endpoint.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/support/time.h>
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/event_engine/closure.h"
+#include "src/core/lib/iomgr/event_engine/pollset.h"
+#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/resource_quota.h"
+#include "src/core/lib/transport/error_utils.h"
+
+extern grpc_core::TraceFlag grpc_tcp_trace;
+
+namespace {
+
+using ::grpc_event_engine::experimental::EventEngine;
+using ::grpc_event_engine::experimental::ResolvedAddressToURI;
+using ::grpc_event_engine::experimental::SliceBuffer;
+
+void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                   grpc_closure* cb, bool /* urgent */) {
+  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
+  if (eeep->endpoint == nullptr) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, GRPC_ERROR_CANCELLED);
+    return;
+  }
+  SliceBuffer* read_buffer = new (&eeep->read_buffer) SliceBuffer(slices);
+  eeep->endpoint->Read(
+      [eeep, cb](absl::Status status) {
+        auto* read_buffer = reinterpret_cast<SliceBuffer*>(&eeep->read_buffer);
+        read_buffer->~SliceBuffer();
+        grpc_core::ExecCtx exec_ctx;
+        grpc_core::Closure::Run(DEBUG_LOCATION, cb,
+                                absl_status_to_grpc_error(status));
+        exec_ctx.Flush();
+        grpc_pollset_ee_broadcast_event();
+      },
+      read_buffer, absl::InfiniteFuture());
+}
+
+void endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                    grpc_closure* cb, void* arg) {
+  // TODO(hork): adapt arg to some metrics collection mechanism.
+  (void)arg;
+  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
+  if (eeep->endpoint == nullptr) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, GRPC_ERROR_CANCELLED);
+    return;
+  }
+  SliceBuffer* write_buffer = new (&eeep->write_buffer) SliceBuffer(slices);
+  eeep->endpoint->Write(
+      [eeep, cb](absl::Status status) {
+        auto* write_buffer =
+            reinterpret_cast<SliceBuffer*>(&eeep->write_buffer);
+        write_buffer->~SliceBuffer();
+        grpc_core::ExecCtx exec_ctx;
+        grpc_core::Closure::Run(DEBUG_LOCATION, cb,
+                                absl_status_to_grpc_error(status));
+        exec_ctx.Flush();
+        grpc_pollset_ee_broadcast_event();
+      },
+      write_buffer, absl::InfiniteFuture());
+}
+void endpoint_add_to_pollset(grpc_endpoint* /* ep */,
+                             grpc_pollset* /* pollset */) {}
+void endpoint_add_to_pollset_set(grpc_endpoint* /* ep */,
+                                 grpc_pollset_set* /* pollset */) {}
+void endpoint_delete_from_pollset_set(grpc_endpoint* /* ep */,
+                                      grpc_pollset_set* /* pollset */) {}
+/// After shutdown, all endpoint operations except destroy are no-op,
+/// and will return some kind of sane default (empty strings, nullptrs, etc). It
+/// is the caller's responsibility to ensure that calls to endpoint_shutdown are
+/// synchronized.
+void endpoint_shutdown(grpc_endpoint* ep, grpc_error* why) {
+  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+    const char* str = grpc_error_string(why);
+    gpr_log(GPR_INFO, "TCP Endpoint %p shutdown why=%s", eeep->endpoint.get(),
+            str);
+  }
+  grpc_resource_user_shutdown(eeep->ru);
+  eeep->endpoint.reset();
+}
+
+void endpoint_destroy(grpc_endpoint* ep) {
+  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
+  grpc_resource_user_unref(eeep->ru);
+  delete eeep;
+}
+
+grpc_resource_user* endpoint_get_resource_user(grpc_endpoint* ep) {
+  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
+  return eeep->ru;
+}
+
+absl::string_view endpoint_get_peer(grpc_endpoint* ep) {
+  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
+  if (eeep->endpoint == nullptr) {
+    return "";
+  }
+  if (eeep->peer_address.empty()) {
+    const EventEngine::ResolvedAddress* addr = eeep->endpoint->GetPeerAddress();
+    GPR_ASSERT(addr != nullptr);
+    eeep->peer_address = ResolvedAddressToURI(*addr);
+  }
+  return eeep->peer_address;
+}
+
+absl::string_view endpoint_get_local_address(grpc_endpoint* ep) {
+  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
+  if (eeep->endpoint == nullptr) {
+    return "";
+  }
+  if (eeep->local_address.empty()) {
+    const EventEngine::ResolvedAddress* addr =
+        eeep->endpoint->GetLocalAddress();
+    GPR_ASSERT(addr != nullptr);
+    eeep->local_address = ResolvedAddressToURI(*addr);
+  }
+  return eeep->local_address;
+}
+
+int endpoint_get_fd(grpc_endpoint* /* ep */) { return -1; }
+
+bool endpoint_can_track_err(grpc_endpoint* /* ep */) { return false; }
+
+grpc_endpoint_vtable grpc_event_engine_endpoint_vtable = {
+    endpoint_read,
+    endpoint_write,
+    endpoint_add_to_pollset,
+    endpoint_add_to_pollset_set,
+    endpoint_delete_from_pollset_set,
+    endpoint_shutdown,
+    endpoint_destroy,
+    endpoint_get_resource_user,
+    endpoint_get_peer,
+    endpoint_get_local_address,
+    endpoint_get_fd,
+    endpoint_can_track_err};
+
+}  // namespace
+
+grpc_event_engine_endpoint* grpc_tcp_server_endpoint_create(
+    std::unique_ptr<EventEngine::Endpoint> ee_endpoint) {
+  auto endpoint = new grpc_event_engine_endpoint;
+  endpoint->base.vtable = &grpc_event_engine_endpoint_vtable;
+  // TODO(hork): populate endpoint->ru from the uvEngine's subclass
+  endpoint->endpoint = std::move(ee_endpoint);
+  return endpoint;
+}
+
+grpc_endpoint* grpc_tcp_create(const grpc_channel_args* channel_args,
+                               absl::string_view peer_address) {
+  auto endpoint = new grpc_event_engine_endpoint;
+  endpoint->base.vtable = &grpc_event_engine_endpoint_vtable;
+  grpc_resource_quota* resource_quota =
+      grpc_channel_args_find_pointer<grpc_resource_quota>(
+          channel_args, GRPC_ARG_RESOURCE_QUOTA);
+  if (resource_quota != nullptr) {
+    grpc_resource_quota_ref_internal(resource_quota);
+  } else {
+    resource_quota = grpc_resource_quota_create(nullptr);
+  }
+  endpoint->ru = grpc_resource_user_create(resource_quota,
+                                           std::string(peer_address).c_str());
+  grpc_resource_quota_unref_internal(resource_quota);
+  return &endpoint->base;
+}
+
+#endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/iomgr/event_engine/endpoint.h

@@ -0,0 +1,53 @@
+// 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_IOMGR_EVENT_ENGINE_ENDPOINT_H
+#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_ENDPOINT_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GRPC_USE_EVENT_ENGINE
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/resource_quota.h"
+
+struct grpc_event_engine_endpoint {
+  grpc_endpoint base;
+  std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+      endpoint;
+  std::string peer_address;
+  std::string local_address;
+  grpc_resource_user* ru = nullptr;
+  std::aligned_storage<
+      sizeof(grpc_event_engine::experimental::SliceBuffer),
+      alignof(grpc_event_engine::experimental::SliceBuffer)>::type read_buffer;
+  std::aligned_storage<
+      sizeof(grpc_event_engine::experimental::SliceBuffer),
+      alignof(grpc_event_engine::experimental::SliceBuffer)>::type write_buffer;
+};
+
+/// Creates an internal grpc_endpoint struct from an EventEngine Endpoint.
+/// Server code needs to create grpc_endpoints after the EventEngine has made
+/// connections.
+grpc_event_engine_endpoint* grpc_tcp_server_endpoint_create(
+    std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint> ee);
+
+/// Creates a new internal grpc_endpoint struct, when no EventEngine Endpoint
+/// has yet been created. This is used in client code before connections are
+/// established.
+grpc_endpoint* grpc_tcp_create(const grpc_channel_args* channel_args,
+                               absl::string_view peer_address);
+
+#endif
+#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_ENDPOINT_H

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

@@ -0,0 +1,105 @@
+// 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>
+
+#ifdef GRPC_USE_EVENT_ENGINE
+#include "src/core/lib/iomgr/event_engine/iomgr.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/event_engine/promise.h"
+#include "src/core/lib/iomgr/iomgr_internal.h"
+#include "src/core/lib/iomgr/tcp_client.h"
+#include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/surface/init.h"
+
+extern grpc_tcp_client_vtable grpc_event_engine_tcp_client_vtable;
+extern grpc_tcp_server_vtable grpc_event_engine_tcp_server_vtable;
+extern grpc_timer_vtable grpc_event_engine_timer_vtable;
+extern grpc_pollset_vtable grpc_event_engine_pollset_vtable;
+extern grpc_pollset_set_vtable grpc_event_engine_pollset_set_vtable;
+extern grpc_address_resolver_vtable grpc_event_engine_resolver_vtable;
+
+// Disabled by default. grpc_polling_trace must be defined in all iomgr
+// implementations due to its usage in lockfree_event.
+grpc_core::DebugOnlyTraceFlag grpc_polling_trace(false, "polling");
+
+namespace {
+
+using ::grpc_event_engine::experimental::DefaultEventEngineFactory;
+using ::grpc_event_engine::experimental::EventEngine;
+using ::grpc_event_engine::experimental::Promise;
+
+// Note: This is a pointer to a shared_ptr, so it's trivially destructible.
+std::shared_ptr<EventEngine>* g_event_engine;
+
+void iomgr_platform_init(void) {
+  g_event_engine =
+      new std::shared_ptr<EventEngine>(DefaultEventEngineFactory());
+}
+
+void iomgr_platform_flush(void) {}
+
+void iomgr_platform_shutdown(void) {
+  Promise<absl::Status> shutdown_status_promise;
+  (*g_event_engine)->Shutdown([&shutdown_status_promise](absl::Status status) {
+    shutdown_status_promise.Set(std::move(status));
+  });
+  auto shutdown_status = shutdown_status_promise.Get();
+  GPR_ASSERT(shutdown_status.ok());
+  delete g_event_engine;
+  g_event_engine = nullptr;
+}
+
+void iomgr_platform_shutdown_background_closure(void) {}
+
+bool iomgr_platform_is_any_background_poller_thread(void) {
+  return (*g_event_engine)->IsWorkerThread();
+}
+
+bool iomgr_platform_add_closure_to_background_poller(
+    grpc_closure* /* closure */, grpc_error* /* error */) {
+  return false;
+}
+
+grpc_iomgr_platform_vtable vtable = {
+    iomgr_platform_init,
+    iomgr_platform_flush,
+    iomgr_platform_shutdown,
+    iomgr_platform_shutdown_background_closure,
+    iomgr_platform_is_any_background_poller_thread,
+    iomgr_platform_add_closure_to_background_poller};
+
+}  // namespace
+
+void grpc_set_default_iomgr_platform() {
+  grpc_set_tcp_client_impl(&grpc_event_engine_tcp_client_vtable);
+  grpc_set_tcp_server_impl(&grpc_event_engine_tcp_server_vtable);
+  grpc_set_timer_impl(&grpc_event_engine_timer_vtable);
+  grpc_set_pollset_vtable(&grpc_event_engine_pollset_vtable);
+  grpc_set_pollset_set_vtable(&grpc_event_engine_pollset_set_vtable);
+  grpc_set_resolver_impl(&grpc_event_engine_resolver_vtable);
+  grpc_set_iomgr_platform_vtable(&vtable);
+}
+
+bool grpc_iomgr_run_in_background() { return false; }
+
+grpc_event_engine::experimental::EventEngine* grpc_iomgr_event_engine() {
+  return g_event_engine->get();
+}
+
+#endif  // GRPC_USE_EVENT_ENGINE