grpc 1.28.0 → 1.31.0.pre2

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

@@ -0,0 +1,43 @@
+/*
+ *
+ * Copyright 2020 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_EV_APPLE_H
+#define GRPC_CORE_LIB_IOMGR_EV_APPLE_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GRPC_APPLE_EV
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+
+void grpc_apple_register_read_stream(CFReadStreamRef read_stream,
+                                     dispatch_queue_t dispatch_queue);
+
+void grpc_apple_register_write_stream(CFWriteStreamRef write_stream,
+                                      dispatch_queue_t dispatch_queue);
+
+extern grpc_pollset_vtable grpc_apple_pollset_vtable;
+
+extern grpc_pollset_set_vtable grpc_apple_pollset_set_vtable;
+
+#endif
+
+#endif

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

@@ -38,9 +38,15 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
+#include <string>
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/string.h"
@@ -346,16 +352,14 @@ static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
 
   new_fd->freelist_next = nullptr;
 
-  char* fd_name;
-  gpr_asprintf(&fd_name, "%s fd=%d", name, fd);
-  grpc_iomgr_register_object(&new_fd->iomgr_object, fd_name);
+  std::string fd_name = absl::StrCat(name, " fd=", fd);
+  grpc_iomgr_register_object(&new_fd->iomgr_object, fd_name.c_str());
   fork_fd_list_add_grpc_fd(new_fd);
 #ifndef NDEBUG
   if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fd_refcount)) {
-    gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, new_fd, fd_name);
+    gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, new_fd, fd_name.c_str());
   }
 #endif
-  gpr_free(fd_name);
 
   struct epoll_event ev;
   ev.events = static_cast<uint32_t>(EPOLLIN | EPOLLOUT | EPOLLET);
@@ -1064,30 +1068,23 @@ static grpc_error* pollset_kick(grpc_pollset* pollset,
   GRPC_STATS_INC_POLLSET_KICK();
   grpc_error* ret_err = GRPC_ERROR_NONE;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-    gpr_strvec log;
-    gpr_strvec_init(&log);
-    char* tmp;
-    gpr_asprintf(&tmp, "PS:%p KICK:%p curps=%p curworker=%p root=%p", pollset,
-                 specific_worker, (void*)gpr_tls_get(&g_current_thread_pollset),
-                 (void*)gpr_tls_get(&g_current_thread_worker),
-                 pollset->root_worker);
-    gpr_strvec_add(&log, tmp);
+    std::vector<std::string> log;
+    log.push_back(absl::StrFormat(
+        "PS:%p KICK:%p curps=%p curworker=%p root=%p", pollset, specific_worker,
+        (void*)gpr_tls_get(&g_current_thread_pollset),
+        (void*)gpr_tls_get(&g_current_thread_worker), pollset->root_worker));
     if (pollset->root_worker != nullptr) {
-      gpr_asprintf(&tmp, " {kick_state=%s next=%p {kick_state=%s}}",
-                   kick_state_string(pollset->root_worker->state),
-                   pollset->root_worker->next,
-                   kick_state_string(pollset->root_worker->next->state));
-      gpr_strvec_add(&log, tmp);
+      log.push_back(absl::StrFormat(
+          " {kick_state=%s next=%p {kick_state=%s}}",
+          kick_state_string(pollset->root_worker->state),
+          pollset->root_worker->next,
+          kick_state_string(pollset->root_worker->next->state)));
     }
     if (specific_worker != nullptr) {
-      gpr_asprintf(&tmp, " worker_kick_state=%s",
-                   kick_state_string(specific_worker->state));
-      gpr_strvec_add(&log, tmp);
+      log.push_back(absl::StrFormat(" worker_kick_state=%s",
+                                    kick_state_string(specific_worker->state)));
     }
-    tmp = gpr_strvec_flatten(&log, nullptr);
-    gpr_strvec_destroy(&log);
-    gpr_log(GPR_DEBUG, "%s", tmp);
-    gpr_free(tmp);
+    gpr_log(GPR_DEBUG, "%s", absl::StrJoin(log, "").c_str());
   }
 
   if (specific_worker == nullptr) {
@@ -1116,9 +1113,8 @@ static grpc_error* pollset_kick(grpc_pollset* pollset,
         }
         SET_KICK_STATE(next_worker, KICKED);
         goto done;
-      } else if (root_worker ==
-                     next_worker &&  // only try and wake up a poller if
-                                     // there is no next worker
+      } else if (root_worker == next_worker &&  // only try and wake up a poller
+                                                // if there is no next worker
                  root_worker == (grpc_pollset_worker*)gpr_atm_no_barrier_load(
                                     &g_active_poller)) {
         GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD();

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

@@ -38,10 +38,14 @@
 #include <sys/syscall.h>
 #include <unistd.h>
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <string>
 
 #include "absl/container/inlined_vector.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+
+#include <grpc/support/alloc.h>
+
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/spinlock.h"
 #include "src/core/lib/gpr/tls.h"
@@ -63,10 +67,6 @@
 //#define GRPC_EPOLLEX_CREATE_WORKERS_ON_HEAP 1
 
 #define MAX_EPOLL_EVENTS 100
-// TODO(juanlishen): We use a greater-than-one value here as a workaround fix to
-// a keepalive ping timeout issue. We may want to revert https://github
-// .com/grpc/grpc/pull/14943 once we figure out the root cause.
-#define MAX_EPOLL_EVENTS_HANDLED_EACH_POLL_CALL 16
 #define MAX_FDS_IN_CACHE 32
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_pollable_refcount(false,
@@ -124,11 +124,10 @@ static const char* pollable_type_string(pollable_type t) {
   return "<invalid>";
 }
 
-static char* pollable_desc(pollable* p) {
-  char* out;
-  gpr_asprintf(&out, "type=%s epfd=%d wakeup=%d", pollable_type_string(p->type),
-               p->epfd, p->wakeup.read_fd);
-  return out;
+static std::string pollable_desc(pollable* p) {
+  return absl::StrFormat("type=%s epfd=%d wakeup=%d",
+                         pollable_type_string(p->type), p->epfd,
+                         p->wakeup.read_fd);
 }
 
 /// Shared empty pollable - used by pollset to poll on until the first fd is
@@ -170,15 +169,13 @@ struct grpc_fd {
     write_closure.InitEvent();
     error_closure.InitEvent();
 
-    char* fd_name;
-    gpr_asprintf(&fd_name, "%s fd=%d", name, fd);
-    grpc_iomgr_register_object(&iomgr_object, fd_name);
+    std::string fd_name = absl::StrCat(name, " fd=", fd);
+    grpc_iomgr_register_object(&iomgr_object, fd_name.c_str());
 #ifndef NDEBUG
     if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fd_refcount)) {
-      gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, this, fd_name);
+      gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, this, fd_name.c_str());
     }
 #endif
-    gpr_free(fd_name);
   }
 
   // This is really the dtor, but the poller threads waking up from
@@ -263,11 +260,10 @@ static void fd_global_shutdown(void);
  * Pollset Declarations
  */
 
-typedef struct {
+struct pwlink {
   grpc_pollset_worker* next;
   grpc_pollset_worker* prev;
-} pwlink;
-
+};
 typedef enum { PWLINK_POLLABLE = 0, PWLINK_POLLSET, PWLINK_COUNT } pwlinks;
 
 struct grpc_pollset_worker {
@@ -873,8 +869,6 @@ static grpc_error* pollable_process_events(grpc_pollset* pollset,
       (pollable_obj->event_count - pollable_obj->event_cursor) / worker_count;
   if (handle_count == 0) {
     handle_count = 1;
-  } else if (handle_count > MAX_EPOLL_EVENTS_HANDLED_EACH_POLL_CALL) {
-    handle_count = MAX_EPOLL_EVENTS_HANDLED_EACH_POLL_CALL;
   }
   grpc_error* error = GRPC_ERROR_NONE;
   for (int i = 0; (drain || i < handle_count) &&
@@ -935,9 +929,8 @@ static grpc_error* pollable_epoll(pollable* p, grpc_millis deadline) {
   int timeout = poll_deadline_to_millis_timeout(deadline);
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-    char* desc = pollable_desc(p);
-    gpr_log(GPR_INFO, "POLLABLE:%p[%s] poll for %dms", p, desc, timeout);
-    gpr_free(desc);
+    gpr_log(GPR_INFO, "POLLABLE:%p[%s] poll for %dms", p,
+            pollable_desc(p).c_str(), timeout);
   }
 
   if (timeout != 0) {

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

@@ -32,9 +32,12 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
+#include <string>
+
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/murmur_hash.h"
@@ -307,9 +310,9 @@ static void fork_fd_list_add_wakeup_fd(grpc_cached_wakeup_fd* fd) {
   }
 }
 
-  /*******************************************************************************
-   * fd_posix.c
-   */
+/*******************************************************************************
+ * fd_posix.c
+ */
 
 #ifndef NDEBUG
 #define REF_BY(fd, n, reason) ref_by(fd, n, reason, __FILE__, __LINE__)
@@ -381,10 +384,8 @@ static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
   r->released = 0;
   gpr_atm_no_barrier_store(&r->pollhup, 0);
 
-  char* name2;
-  gpr_asprintf(&name2, "%s fd=%d", name, fd);
-  grpc_iomgr_register_object(&r->iomgr_object, name2);
-  gpr_free(name2);
+  std::string name2 = absl::StrCat(name, " fd=", fd);
+  grpc_iomgr_register_object(&r->iomgr_object, name2.c_str());
   fork_fd_list_add_grpc_fd(r);
   return r;
 }

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

@@ -37,6 +37,7 @@
 #include "src/core/lib/iomgr/ev_epollex_linux.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
+#include "src/core/lib/iomgr/iomgr.h"
 
 GPR_GLOBAL_CONFIG_DEFINE_STRING(
     grpc_poll_strategy, "all",
@@ -81,11 +82,10 @@ static const char* g_poll_strategy_name = nullptr;
 typedef const grpc_event_engine_vtable* (*event_engine_factory_fn)(
     bool explicit_request);
 
-typedef struct {
+struct event_engine_factory {
   const char* name;
   event_engine_factory_fn factory;
-} event_engine_factory;
-
+};
 namespace {
 
 grpc_poll_function_type real_poll_function;
@@ -108,6 +108,7 @@ const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
   auto ret = grpc_init_poll_posix(explicit_request);
   real_poll_function = grpc_poll_function;
   grpc_poll_function = dummy_poll;
+  grpc_iomgr_mark_non_polling_internal();
 
   return ret;
 }

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <limits>
+
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
@@ -132,7 +134,12 @@ class ExecCtx {
   ExecCtx(const ExecCtx&) = delete;
   ExecCtx& operator=(const ExecCtx&) = delete;
 
-  unsigned starting_cpu() const { return starting_cpu_; }
+  unsigned starting_cpu() {
+    if (starting_cpu_ == std::numeric_limits<unsigned>::max()) {
+      starting_cpu_ = gpr_cpu_current_cpu();
+    }
+    return starting_cpu_;
+  }
 
   struct CombinerData {
     /* currently active combiner: updated only via combiner.c */
@@ -239,7 +246,7 @@ class ExecCtx {
   CombinerData combiner_data_ = {nullptr, nullptr};
   uintptr_t flags_;
 
-  unsigned starting_cpu_ = gpr_cpu_current_cpu();
+  unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
 
   bool now_is_valid_ = false;
   grpc_millis now_ = 0;
@@ -357,6 +364,11 @@ class ApplicationCallbackExecCtx {
   /** Global shutdown for ApplicationCallbackExecCtx. Called by init. */
   static void GlobalShutdown(void) { gpr_tls_destroy(&callback_exec_ctx_); }
 
+  static bool Available() {
+    return reinterpret_cast<ApplicationCallbackExecCtx*>(
+               gpr_tls_get(&callback_exec_ctx_)) != nullptr;
+  }
+
  private:
   uintptr_t flags_{0u};
   grpc_experimental_completion_queue_functor* head_{nullptr};

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

@@ -31,6 +31,7 @@
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/buffer_list.h"
@@ -50,6 +51,7 @@ static gpr_cv g_rcv;
 static int g_shutdown;
 static grpc_iomgr_object g_root_object;
 static bool g_grpc_abort_on_leaks;
+static grpc_core::Atomic<bool> g_iomgr_non_polling{false};
 
 void grpc_iomgr_init() {
   grpc_core::ExecCtx exec_ctx;
@@ -192,3 +194,11 @@ void grpc_iomgr_unregister_object(grpc_iomgr_object* obj) {
 }
 
 bool grpc_iomgr_abort_on_leaks(void) { return g_grpc_abort_on_leaks; }
+
+bool grpc_iomgr_non_polling() {
+  return g_iomgr_non_polling.Load(grpc_core::MemoryOrder::SEQ_CST);
+}
+
+void grpc_iomgr_mark_non_polling_internal() {
+  g_iomgr_non_polling.Store(true, grpc_core::MemoryOrder::SEQ_CST);
+}

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

@@ -45,6 +45,16 @@ void grpc_iomgr_shutdown_background_closure();
  */
 bool grpc_iomgr_run_in_background();
 
+/* Returns true if polling engine is non-polling, false otherwise.
+ * Currently only 'none' is non-polling.
+ */
+bool grpc_iomgr_non_polling();
+
+/* Mark the polling engine as non-polling. For internal use only.
+ * Currently only 'none' is non-polling.
+ */
+void grpc_iomgr_mark_non_polling_internal();
+
 /** Returns true if the caller is a worker thread for any background poller. */
 bool grpc_iomgr_is_any_background_poller_thread();
 

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

@@ -16,6 +16,20 @@
  *
  */
 
+/// CFStream is build-enabled on iOS by default and disabled by default on other
+/// platforms (see port_platform.h). To enable CFStream build on another
+/// platform, the users need to define macro "GRPC_CFSTREAM=1" when building
+/// gRPC.
+///
+/// When CFStream is to be built (either by default on iOS or by macro on other
+/// platforms), the users can disable CFStream with environment variable
+/// "grpc_cfstream=0". This will let gRPC to fallback to use POSIX sockets. In
+/// addition, the users may choose to use an alternative CFRunLoop based pollset
+/// "ev_apple" by setting environment variable "GRPC_CFSTREAM_RUN_LOOP=1". This
+/// pollset resolves a bug from Apple when CFStream streams dispatch events to
+/// dispatch queues. The caveat of this pollset is that users may not be able to
+/// run a gRPC server in the same process.
+
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/port.h"
@@ -23,6 +37,7 @@
 #ifdef GRPC_CFSTREAM_IOMGR
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/iomgr/ev_apple.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/iomgr_posix.h"
@@ -33,6 +48,7 @@
 #include "src/core/lib/iomgr/timer.h"
 
 static const char* grpc_cfstream_env_var = "grpc_cfstream";
+static const char* grpc_cfstream_run_loop_env_var = "GRPC_CFSTREAM_RUN_LOOP";
 
 extern grpc_tcp_server_vtable grpc_posix_tcp_server_vtable;
 extern grpc_tcp_client_vtable grpc_posix_tcp_client_vtable;
@@ -42,6 +58,33 @@ extern grpc_pollset_vtable grpc_posix_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_posix_pollset_set_vtable;
 extern grpc_address_resolver_vtable grpc_posix_resolver_vtable;
 
+static void apple_iomgr_platform_init(void) { grpc_pollset_global_init(); }
+
+static void apple_iomgr_platform_flush(void) {}
+
+static void apple_iomgr_platform_shutdown(void) {
+  grpc_pollset_global_shutdown();
+}
+
+static void apple_iomgr_platform_shutdown_background_closure(void) {}
+
+static bool apple_iomgr_platform_is_any_background_poller_thread(void) {
+  return false;
+}
+
+static bool apple_iomgr_platform_add_closure_to_background_poller(
+    grpc_closure* closure, grpc_error* error) {
+  return false;
+}
+
+static grpc_iomgr_platform_vtable apple_vtable = {
+    apple_iomgr_platform_init,
+    apple_iomgr_platform_flush,
+    apple_iomgr_platform_shutdown,
+    apple_iomgr_platform_shutdown_background_closure,
+    apple_iomgr_platform_is_any_background_poller_thread,
+    apple_iomgr_platform_add_closure_to_background_poller};
+
 static void iomgr_platform_init(void) {
   grpc_wakeup_fd_global_init();
   grpc_event_engine_init();
@@ -76,32 +119,53 @@ static grpc_iomgr_platform_vtable vtable = {
     iomgr_platform_add_closure_to_background_poller};
 
 void grpc_set_default_iomgr_platform() {
-  char* enable_cfstream = getenv(grpc_cfstream_env_var);
-  grpc_tcp_client_vtable* client_vtable = &grpc_posix_tcp_client_vtable;
-  // CFStream is enabled by default on iOS, and disabled by default on other
-  // platforms. Defaults can be overriden by setting the grpc_cfstream
-  // environment variable.
-#if TARGET_OS_IPHONE
-  if (enable_cfstream == nullptr || enable_cfstream[0] == '1') {
-    client_vtable = &grpc_cfstream_client_vtable;
+  char* enable_cfstream_str = getenv(grpc_cfstream_env_var);
+  bool enable_cfstream =
+      enable_cfstream_str == nullptr || enable_cfstream_str[0] != '0';
+  char* enable_cfstream_run_loop_str = getenv(grpc_cfstream_run_loop_env_var);
+  // CFStream run-loop is disabled by default. The user has to enable it
+  // explicitly with environment variable.
+  bool enable_cfstream_run_loop = enable_cfstream_run_loop_str != nullptr &&
+                                  enable_cfstream_run_loop_str[0] == '1';
+  if (!enable_cfstream) {
+    // Use POSIX sockets for both client and server
+    grpc_set_tcp_client_impl(&grpc_posix_tcp_client_vtable);
+    grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);
+    grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
+    grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
+    grpc_set_iomgr_platform_vtable(&vtable);
+  } else if (enable_cfstream && !enable_cfstream_run_loop) {
+    // Use CFStream with dispatch queue for client; use POSIX sockets for server
+    grpc_set_tcp_client_impl(&grpc_cfstream_client_vtable);
+    grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);
+    grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
+    grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
+    grpc_set_iomgr_platform_vtable(&vtable);
+  } else {
+    // Use CFStream with CFRunLoop for client; server not supported
+    grpc_set_tcp_client_impl(&grpc_cfstream_client_vtable);
+    grpc_set_pollset_vtable(&grpc_apple_pollset_vtable);
+    grpc_set_pollset_set_vtable(&grpc_apple_pollset_set_vtable);
+    grpc_set_iomgr_platform_vtable(&apple_vtable);
   }
-#else
-  if (enable_cfstream != nullptr && enable_cfstream[0] == '1') {
-    client_vtable = &grpc_cfstream_client_vtable;
-  }
-#endif
-
-  grpc_set_tcp_client_impl(client_vtable);
-  grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
-  grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
-  grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
   grpc_set_resolver_impl(&grpc_posix_resolver_vtable);
-  grpc_set_iomgr_platform_vtable(&vtable);
 }
 
 bool grpc_iomgr_run_in_background() {
-  return grpc_event_engine_run_in_background();
+  char* enable_cfstream_str = getenv(grpc_cfstream_env_var);
+  bool enable_cfstream =
+      enable_cfstream_str == nullptr || enable_cfstream_str[0] != '0';
+  char* enable_cfstream_run_loop_str = getenv(grpc_cfstream_run_loop_env_var);
+  // CFStream run-loop is disabled by default. The user has to enable it
+  // explicitly with environment variable.
+  bool enable_cfstream_run_loop = enable_cfstream_run_loop_str != nullptr &&
+                                  enable_cfstream_run_loop_str[0] == '1';
+  if (enable_cfstream && enable_cfstream_run_loop) {
+    return false;
+  } else {
+    return grpc_event_engine_run_in_background();
+  }
 }
 
 #endif /* GRPC_CFSTREAM_IOMGR */