grpc 1.49.1-x86_64-linux → 1.50.0.pre1-x86_64-linux

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

@@ -176,30 +176,14 @@ class ExecCtx {
     }
   }
 
-  /** Returns the stored current time relative to start if valid,
-   *  otherwise refreshes the stored time, sets it valid and returns the new
-   *  value.
-   */
-  Timestamp Now();
-
-  /** Invalidates the stored time value. A new time value will be set on calling
-   *  Now().
-   */
-  void InvalidateNow() { now_is_valid_ = false; }
-
-  /** To be used only by shutdown code in iomgr */
+  Timestamp Now() { return Timestamp::Now(); }
+  void InvalidateNow() { time_cache_.InvalidateCache(); }
   void SetNowIomgrShutdown() {
-    now_ = Timestamp::InfFuture();
-    now_is_valid_ = true;
-  }
-
-  /** To be used only for testing.
-   *  Sets the now value.
-   */
-  void TestOnlySetNow(Timestamp new_val) {
-    now_ = new_val;
-    now_is_valid_ = true;
+    // We get to do a test only set now on this path just because iomgr
+    // is getting removed and no point adding more interfaces for it.
+    time_cache_.TestOnlySetNow(Timestamp::InfFuture());
   }
+  void TestOnlySetNow(Timestamp now) { time_cache_.TestOnlySetNow(now); }
 
   /** Gets pointer to current exec_ctx. */
   static ExecCtx* Get() { return exec_ctx_; }
@@ -226,9 +210,7 @@ class ExecCtx {
 
   unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
 
-  bool now_is_valid_ = false;
-  Timestamp now_;
-
+  ScopedTimeCache time_cache_;
   static GPR_THREAD_LOCAL(ExecCtx*) exec_ctx_;
   ExecCtx* last_exec_ctx_ = Get();
 };
@@ -338,12 +320,6 @@ class ApplicationCallbackExecCtx {
     ctx->tail_ = functor;
   }
 
-  /** Global initialization for ApplicationCallbackExecCtx. Called by init. */
-  static void GlobalInit(void) {}
-
-  /** Global shutdown for ApplicationCallbackExecCtx. Called by init. */
-  static void GlobalShutdown(void) {}
-
   static bool Available() { return Get() != nullptr; }
 
  private:

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

@@ -48,7 +48,7 @@ static DWORD deadline_to_millis_timeout(grpc_core::Timestamp deadline) {
   if (deadline == grpc_core::Timestamp::InfFuture()) {
     return INFINITE;
   }
-  grpc_core::Timestamp now = grpc_core::ExecCtx::Get()->Now();
+  grpc_core::Timestamp now = grpc_core::Timestamp::Now();
   if (deadline < now) return 0;
   grpc_core::Duration timeout = deadline - now;
   if (timeout.millis() > std::numeric_limits<DWORD>::max()) return INFINITE;
@@ -63,7 +63,6 @@ grpc_iocp_work_status grpc_iocp_work(grpc_core::Timestamp deadline) {
   LPOVERLAPPED overlapped;
   grpc_winsocket* socket;
   grpc_winsocket_callback_info* info;
-  GRPC_STATS_INC_SYSCALL_POLL();
   success =
       GetQueuedCompletionStatus(g_iocp, &bytes, &completion_key, &overlapped,
                                 deadline_to_millis_timeout(deadline));

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

@@ -45,13 +45,6 @@ GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_abort_on_leaks, false,
                               "A debugging aid to cause a call to abort() when "
                               "gRPC objects are leaked past grpc_shutdown()");
 
-GPR_GLOBAL_CONFIG_DEFINE_BOOL(
-    grpc_experimental_enable_tcp_frame_size_tuning, false,
-    "If set, enables TCP to use RPC size estimation made by higher layers. TCP "
-    "would not indicate completion of a read operation until a specified "
-    "number of bytes have been read over the socket. Buffers are also "
-    "allocated according to estimated RPC sizes.");
-
 static gpr_mu g_mu;
 static gpr_cv g_rcv;
 static int g_shutdown;
@@ -85,7 +78,12 @@ static size_t count_objects(void) {
   return n;
 }
 
-size_t grpc_iomgr_count_objects_for_testing(void) { return count_objects(); }
+size_t grpc_iomgr_count_objects_for_testing(void) {
+  gpr_mu_lock(&g_mu);
+  size_t ret = count_objects();
+  gpr_mu_unlock(&g_mu);
+  return ret;
+}
 
 static void dump_objects(const char* kind) {
   grpc_iomgr_object* obj;

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

@@ -21,5 +21,6 @@
 #include <grpc/support/port_platform.h>
 
 typedef struct grpc_pollset_set grpc_pollset_set;
+typedef struct grpc_pollset grpc_pollset;
 
 #endif  // GRPC_CORE_LIB_IOMGR_IOMGR_FWD_H

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

@@ -25,6 +25,7 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_fd_refcount;
 
@@ -35,7 +36,6 @@ extern grpc_core::DebugOnlyTraceFlag grpc_trace_fd_refcount;
     - a completion queue might keep a pollset with an entry for each transport
       that is servicing a call that it's tracking */
 
-typedef struct grpc_pollset grpc_pollset;
 typedef struct grpc_pollset_worker grpc_pollset_worker;
 
 typedef struct grpc_pollset_vtable {

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

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/iomgr/pollset.h"
 
 /* A grpc_pollset_set is a set of pollsets that are interested in an
    action. Adding a pollset to a pollset_set automatically adds any

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

@@ -28,6 +28,7 @@
 #include <grpc/event_engine/event_engine.h>
 
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolved_address.h"

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

@@ -21,6 +21,7 @@
 
 #include <stddef.h>
 
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 

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

@@ -35,6 +35,7 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/block_annotate.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"

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

@@ -39,6 +39,7 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/block_annotate.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"

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

@@ -23,6 +23,8 @@
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
 
 #include "src/core/lib/iomgr/socket_utils.h"
+// sys/types.h must precede netinet/tcp.h for compatibility.
+#include <sys/types.h>
 #ifdef GRPC_LINUX_TCP_H
 #include <linux/tcp.h>
 #else
@@ -31,7 +33,6 @@
 #include <stdio.h>
 #include <string.h>
 #include <sys/socket.h>
-#include <sys/types.h>
 #include <unistd.h>
 
 #include <string>

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

@@ -43,12 +43,12 @@
 
 #include <string>
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 
@@ -298,10 +298,9 @@ void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client) {
 
 /* Set TCP_USER_TIMEOUT */
 grpc_error_handle grpc_set_socket_tcp_user_timeout(
-    int fd, const grpc_channel_args* channel_args, bool is_client) {
+    int fd, const grpc_core::PosixTcpOptions& options, bool is_client) {
   // Use conditionally-important parameter to avoid warning
   (void)fd;
-  (void)channel_args;
   (void)is_client;
   extern grpc_core::TraceFlag grpc_tcp_trace;
   if (g_socket_supports_tcp_user_timeout.load() >= 0) {
@@ -314,29 +313,13 @@ grpc_error_handle grpc_set_socket_tcp_user_timeout(
       enable = g_default_server_tcp_user_timeout_enabled;
       timeout = g_default_server_tcp_user_timeout_ms;
     }
-    if (channel_args) {
-      for (unsigned int i = 0; i < channel_args->num_args; i++) {
-        if (0 ==
-            strcmp(channel_args->args[i].key, GRPC_ARG_KEEPALIVE_TIME_MS)) {
-          const int value = grpc_channel_arg_get_integer(
-              &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
-          /* Continue using default if value is 0 */
-          if (value == 0) {
-            continue;
-          }
-          /* Disable if value is INT_MAX */
-          enable = value != INT_MAX;
-        } else if (0 == strcmp(channel_args->args[i].key,
-                               GRPC_ARG_KEEPALIVE_TIMEOUT_MS)) {
-          const int value = grpc_channel_arg_get_integer(
-              &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
-          /* Continue using default if value is 0 */
-          if (value == 0) {
-            continue;
-          }
-          timeout = value;
-        }
-      }
+    int value = options.keep_alive_time_ms;
+    if (value > 0) {
+      enable = value != INT_MAX;
+    }
+    value = options.keep_alive_timeout_ms;
+    if (value > 0) {
+      timeout = value;
     }
     if (enable) {
       int newval;
@@ -398,16 +381,11 @@ grpc_error_handle grpc_set_socket_with_mutator(int fd, grpc_fd_usage usage,
 }
 
 grpc_error_handle grpc_apply_socket_mutator_in_args(
-    int fd, grpc_fd_usage usage, const grpc_channel_args* args) {
-  const grpc_arg* socket_mutator_arg =
-      grpc_channel_args_find(args, GRPC_ARG_SOCKET_MUTATOR);
-  if (socket_mutator_arg == nullptr) {
+    int fd, grpc_fd_usage usage, const grpc_core::PosixTcpOptions& options) {
+  if (options.socket_mutator == nullptr) {
     return GRPC_ERROR_NONE;
   }
-  GPR_DEBUG_ASSERT(socket_mutator_arg->type == GRPC_ARG_POINTER);
-  grpc_socket_mutator* mutator =
-      static_cast<grpc_socket_mutator*>(socket_mutator_arg->value.pointer.p);
-  return grpc_set_socket_with_mutator(fd, usage, mutator);
+  return grpc_set_socket_with_mutator(fd, usage, options.socket_mutator);
 }
 
 static gpr_once g_probe_ipv6_once = GPR_ONCE_INIT;

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

@@ -18,18 +18,100 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/types/optional.h"
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKETUTILS
-
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
+#endif
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+#include "src/core/lib/iomgr/socket_utils_posix.h"
+
+using ::grpc_event_engine::experimental::EndpointConfig;
+
+using ::grpc_core::PosixTcpOptions;
+
+namespace {
+
+int AdjustValue(int default_value, int min_value, int max_value,
+                absl::optional<int> actual_value) {
+  if (!actual_value.has_value() || *actual_value < min_value ||
+      *actual_value > max_value) {
+    return default_value;
+  }
+  return *actual_value;
+}
+}  // namespace
+
+PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
+  void* value;
+  PosixTcpOptions options;
+  options.tcp_read_chunk_size = AdjustValue(
+      PosixTcpOptions::kDefaultReadChunkSize, 1, PosixTcpOptions::kMaxChunkSize,
+      config.GetInt(GRPC_ARG_TCP_READ_CHUNK_SIZE));
+  options.tcp_min_read_chunk_size =
+      AdjustValue(PosixTcpOptions::kDefaultMinReadChunksize, 1,
+                  PosixTcpOptions::kMaxChunkSize,
+                  config.GetInt(GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE));
+  options.tcp_max_read_chunk_size =
+      AdjustValue(PosixTcpOptions::kDefaultMaxReadChunksize, 1,
+                  PosixTcpOptions::kMaxChunkSize,
+                  config.GetInt(GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE));
+  options.tcp_tx_zerocopy_send_bytes_threshold =
+      AdjustValue(PosixTcpOptions::kDefaultSendBytesThreshold, 0, INT_MAX,
+                  config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD));
+  options.tcp_tx_zerocopy_max_simultaneous_sends =
+      AdjustValue(PosixTcpOptions::kDefaultMaxSends, 0, INT_MAX,
+                  config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS));
+  options.tcp_tx_zero_copy_enabled =
+      (AdjustValue(PosixTcpOptions::kZerocpTxEnabledDefault, 0, 1,
+                   config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED)) != 0);
+  options.keep_alive_time_ms =
+      AdjustValue(0, 1, INT_MAX, config.GetInt(GRPC_ARG_KEEPALIVE_TIME_MS));
+  options.keep_alive_timeout_ms =
+      AdjustValue(0, 1, INT_MAX, config.GetInt(GRPC_ARG_KEEPALIVE_TIMEOUT_MS));
+  options.expand_wildcard_addrs =
+      (AdjustValue(0, 1, INT_MAX,
+                   config.GetInt(GRPC_ARG_EXPAND_WILDCARD_ADDRS)) != 0);
+  options.allow_reuse_port =
+      (AdjustValue(0, 1, INT_MAX, config.GetInt(GRPC_ARG_ALLOW_REUSEPORT)) !=
+       0);
+
+  if (options.tcp_min_read_chunk_size > options.tcp_max_read_chunk_size) {
+    options.tcp_min_read_chunk_size = options.tcp_max_read_chunk_size;
+  }
+  options.tcp_read_chunk_size = grpc_core::Clamp(
+      options.tcp_read_chunk_size, options.tcp_min_read_chunk_size,
+      options.tcp_max_read_chunk_size);
+
+  value = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
+  if (value != nullptr) {
+    options.resource_quota =
+        reinterpret_cast<grpc_core::ResourceQuota*>(value)->Ref();
+  }
+  value = config.GetVoidPointer(GRPC_ARG_SOCKET_MUTATOR);
+  if (value != nullptr) {
+    options.socket_mutator =
+        grpc_socket_mutator_ref(static_cast<grpc_socket_mutator*>(value));
+  }
+  return options;
+}
+
+#endif /* GRPC_POSIX_SOCKET_TCP */
+
+#ifdef GRPC_POSIX_SOCKETUTILS
 
 int grpc_accept4(int sockfd, grpc_resolved_address* resolved_addr, int nonblock,
                  int cloexec) {

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

@@ -21,15 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <sys/socket.h>
-#include <unistd.h>
-
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/socket_factory_posix.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 
 #ifdef GRPC_LINUX_ERRQUEUE
 #ifndef SO_ZEROCOPY
@@ -40,6 +39,98 @@
 #endif
 #endif /* ifdef GRPC_LINUX_ERRQUEUE */
 
+namespace grpc_core {
+
+struct PosixTcpOptions {
+  static constexpr int kDefaultReadChunkSize = 8192;
+  static constexpr int kDefaultMinReadChunksize = 256;
+  static constexpr int kDefaultMaxReadChunksize = 4 * 1024 * 1024;
+  static constexpr int kZerocpTxEnabledDefault = 0;
+  static constexpr int kMaxChunkSize = 32 * 1024 * 1024;
+  static constexpr int kDefaultMaxSends = 4;
+  static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;
+  int tcp_read_chunk_size = kDefaultReadChunkSize;
+  int tcp_min_read_chunk_size = kDefaultMinReadChunksize;
+  int tcp_max_read_chunk_size = kDefaultMaxReadChunksize;
+  int tcp_tx_zerocopy_send_bytes_threshold = kDefaultSendBytesThreshold;
+  int tcp_tx_zerocopy_max_simultaneous_sends = kDefaultMaxSends;
+  bool tcp_tx_zero_copy_enabled = kZerocpTxEnabledDefault;
+  int keep_alive_time_ms = 0;
+  int keep_alive_timeout_ms = 0;
+  bool expand_wildcard_addrs = false;
+  bool allow_reuse_port = false;
+  RefCountedPtr<ResourceQuota> resource_quota;
+  struct grpc_socket_mutator* socket_mutator = nullptr;
+  PosixTcpOptions() = default;
+  // Move ctor
+  PosixTcpOptions(PosixTcpOptions&& other) noexcept {
+    socket_mutator = absl::exchange(other.socket_mutator, nullptr);
+    resource_quota = std::move(other.resource_quota);
+    CopyIntegerOptions(other);
+  }
+  // Move assignment
+  PosixTcpOptions& operator=(PosixTcpOptions&& other) noexcept {
+    if (socket_mutator != nullptr) {
+      grpc_socket_mutator_unref(socket_mutator);
+    }
+    socket_mutator = absl::exchange(other.socket_mutator, nullptr);
+    resource_quota = std::move(other.resource_quota);
+    CopyIntegerOptions(other);
+    return *this;
+  }
+  // Copy ctor
+  PosixTcpOptions(const PosixTcpOptions& other) {
+    if (other.socket_mutator != nullptr) {
+      socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
+    }
+    resource_quota = other.resource_quota;
+    CopyIntegerOptions(other);
+  }
+  // Copy assignment
+  PosixTcpOptions& operator=(const PosixTcpOptions& other) {
+    if (&other == this) {
+      return *this;
+    }
+    if (socket_mutator != nullptr) {
+      grpc_socket_mutator_unref(socket_mutator);
+      socket_mutator = nullptr;
+    }
+    if (other.socket_mutator != nullptr) {
+      socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
+    }
+    resource_quota = other.resource_quota;
+    CopyIntegerOptions(other);
+    return *this;
+  }
+  // Destructor.
+  ~PosixTcpOptions() {
+    if (socket_mutator != nullptr) {
+      grpc_socket_mutator_unref(socket_mutator);
+    }
+  }
+
+ private:
+  void CopyIntegerOptions(const PosixTcpOptions& other) {
+    tcp_read_chunk_size = other.tcp_read_chunk_size;
+    tcp_min_read_chunk_size = other.tcp_min_read_chunk_size;
+    tcp_max_read_chunk_size = other.tcp_max_read_chunk_size;
+    tcp_tx_zerocopy_send_bytes_threshold =
+        other.tcp_tx_zerocopy_send_bytes_threshold;
+    tcp_tx_zerocopy_max_simultaneous_sends =
+        other.tcp_tx_zerocopy_max_simultaneous_sends;
+    tcp_tx_zero_copy_enabled = other.tcp_tx_zero_copy_enabled;
+    keep_alive_time_ms = other.keep_alive_time_ms;
+    keep_alive_timeout_ms = other.keep_alive_timeout_ms;
+    expand_wildcard_addrs = other.expand_wildcard_addrs;
+    allow_reuse_port = other.allow_reuse_port;
+  }
+};
+
+}  // namespace grpc_core
+
+grpc_core::PosixTcpOptions TcpOptionsFromEndpointConfig(
+    const grpc_event_engine::experimental::EndpointConfig& config);
+
 /* a wrapper for accept or accept4 */
 int grpc_accept4(int sockfd, grpc_resolved_address* resolved_addr, int nonblock,
                  int cloexec);
@@ -70,7 +161,7 @@ void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client);
 
 /* Set TCP_USER_TIMEOUT */
 grpc_error_handle grpc_set_socket_tcp_user_timeout(
-    int fd, const grpc_channel_args* channel_args, bool is_client);
+    int fd, const grpc_core::PosixTcpOptions& options, bool is_client);
 
 /* Returns true if this system can create AF_INET6 sockets bound to ::1.
    The value is probed once, and cached for the life of the process.
@@ -104,9 +195,10 @@ grpc_error_handle grpc_set_socket_rcvbuf(int fd, int buffer_size_bytes);
 grpc_error_handle grpc_set_socket_with_mutator(int fd, grpc_fd_usage usage,
                                                grpc_socket_mutator* mutator);
 
-/* Extracts the first socket mutator from args if any and applies on the fd. */
+/* Extracts the first socket mutator from config if any and applies on the fd.
+ */
 grpc_error_handle grpc_apply_socket_mutator_in_args(
-    int fd, grpc_fd_usage usage, const grpc_channel_args* args);
+    int fd, grpc_fd_usage usage, const grpc_core::PosixTcpOptions& options);
 
 /* An enum to keep track of IPv4/IPv6 socket modes.
 

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

@@ -22,14 +22,13 @@
 
 grpc_tcp_client_vtable* grpc_tcp_client_impl;
 
-int64_t grpc_tcp_client_connect(grpc_closure* on_connect,
-                                grpc_endpoint** endpoint,
-                                grpc_pollset_set* interested_parties,
-                                const grpc_channel_args* channel_args,
-                                const grpc_resolved_address* addr,
-                                grpc_core::Timestamp deadline) {
+int64_t grpc_tcp_client_connect(
+    grpc_closure* on_connect, grpc_endpoint** endpoint,
+    grpc_pollset_set* interested_parties,
+    const grpc_event_engine::experimental::EndpointConfig& config,
+    const grpc_resolved_address* addr, grpc_core::Timestamp deadline) {
   return grpc_tcp_client_impl->connect(on_connect, endpoint, interested_parties,
-                                       channel_args, addr, deadline);
+                                       config, addr, deadline);
 }
 
 bool grpc_tcp_client_cancel_connect(int64_t connection_handle) {

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

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/time.h>
 
@@ -30,11 +31,11 @@
 #include "src/core/lib/resource_quota/memory_quota.h"
 
 typedef struct grpc_tcp_client_vtable {
-  int64_t (*connect)(grpc_closure* on_connect, grpc_endpoint** endpoint,
-                     grpc_pollset_set* interested_parties,
-                     const grpc_channel_args* channel_args,
-                     const grpc_resolved_address* addr,
-                     grpc_core::Timestamp deadline);
+  int64_t (*connect)(
+      grpc_closure* on_connect, grpc_endpoint** endpoint,
+      grpc_pollset_set* interested_parties,
+      const grpc_event_engine::experimental::EndpointConfig& config,
+      const grpc_resolved_address* addr, grpc_core::Timestamp deadline);
   bool (*cancel_connect)(int64_t connection_handle);
 } grpc_tcp_client_vtable;
 
@@ -45,12 +46,11 @@ typedef struct grpc_tcp_client_vtable {
    in this connection being established (in order to continue their work). It
    returns a handle to the connect operation which can be used to cancel the
    connection attempt. */
-int64_t grpc_tcp_client_connect(grpc_closure* on_connect,
-                                grpc_endpoint** endpoint,
-                                grpc_pollset_set* interested_parties,
-                                const grpc_channel_args* channel_args,
-                                const grpc_resolved_address* addr,
-                                grpc_core::Timestamp deadline);
+int64_t grpc_tcp_client_connect(
+    grpc_closure* on_connect, grpc_endpoint** endpoint,
+    grpc_pollset_set* interested_parties,
+    const grpc_event_engine::experimental::EndpointConfig& config,
+    const grpc_resolved_address* addr, grpc_core::Timestamp deadline);
 
 // Returns true if a connect attempt corresponding to the provided handle
 // is successfully cancelled. Otherwise it returns false. If the connect

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

@@ -27,12 +27,12 @@
 #include <netinet/in.h>
 #include <string.h>
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/cfstream_handle.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -149,11 +149,11 @@ static void ParseResolvedAddress(const grpc_resolved_address* addr,
   *port = grpc_sockaddr_get_port(addr);
 }
 
-static int64_t CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
-                                     grpc_pollset_set* interested_parties,
-                                     const grpc_channel_args* channel_args,
-                                     const grpc_resolved_address* resolved_addr,
-                                     grpc_core::Timestamp deadline) {
+static int64_t CFStreamClientConnect(
+    grpc_closure* closure, grpc_endpoint** ep,
+    grpc_pollset_set* interested_parties,
+    const grpc_event_engine::experimental::EndpointConfig& /*config*/,
+    const grpc_resolved_address* resolved_addr, grpc_core::Timestamp deadline) {
   auto addr_uri = grpc_sockaddr_to_uri(resolved_addr);
   if (!addr_uri.ok()) {
     grpc_error_handle error =