grpc 1.42.0 → 1.43.1

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

@@ -32,7 +32,6 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/resource_quota.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -63,8 +62,6 @@ struct custom_tcp_endpoint {
   grpc_slice_buffer* read_slices = nullptr;
   grpc_slice_buffer* write_slices = nullptr;
 
-  grpc_slice_allocator* slice_allocator;
-
   bool shutting_down;
 
   std::string peer_string;
@@ -73,7 +70,6 @@ struct custom_tcp_endpoint {
 static void tcp_free(grpc_custom_socket* s) {
   custom_tcp_endpoint* tcp =
       reinterpret_cast<custom_tcp_endpoint*>(s->endpoint);
-  grpc_slice_allocator_destroy(tcp->slice_allocator);
   delete tcp;
   s->refs--;
   if (s->refs == 0) {
@@ -167,31 +163,6 @@ static void custom_read_callback(grpc_custom_socket* socket, size_t nread,
   call_read_cb(tcp, error);
 }
 
-static void tcp_read_allocation_done(void* tcpp, grpc_error_handle error) {
-  custom_tcp_endpoint* tcp = static_cast<custom_tcp_endpoint*>(tcpp);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    gpr_log(GPR_INFO, "TCP:%p read_allocation_done: %s", tcp->socket,
-            grpc_error_std_string(error).c_str());
-  }
-  if (error == GRPC_ERROR_NONE) {
-    /* Before calling read, we allocate a buffer with exactly one slice
-     * to tcp->read_slices and wait for the callback indicating that the
-     * allocation was successful. So slices[0] should always exist here */
-    char* buffer = reinterpret_cast<char*>(
-        GRPC_SLICE_START_PTR(tcp->read_slices->slices[0]));
-    size_t len = GRPC_SLICE_LENGTH(tcp->read_slices->slices[0]);
-    grpc_custom_socket_vtable->read(tcp->socket, buffer, len,
-                                    custom_read_callback);
-  } else {
-    grpc_slice_buffer_reset_and_unref_internal(tcp->read_slices);
-    call_read_cb(tcp, GRPC_ERROR_REF(error));
-  }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    gpr_log(GPR_INFO, "Initiating read on %p: error=%s", tcp->socket,
-            grpc_error_std_string(error).c_str());
-  }
-}
-
 static void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
                           grpc_closure* cb, bool /*urgent*/) {
   custom_tcp_endpoint* tcp = reinterpret_cast<custom_tcp_endpoint*>(ep);
@@ -201,12 +172,16 @@ static void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
   tcp->read_slices = read_slices;
   grpc_slice_buffer_reset_and_unref_internal(read_slices);
   TCP_REF(tcp, "read");
-  if (grpc_slice_allocator_allocate(
-          tcp->slice_allocator, GRPC_TCP_DEFAULT_READ_SLICE_SIZE, 1,
-          grpc_slice_allocator_intent::kReadBuffer, tcp->read_slices,
-          tcp_read_allocation_done, tcp)) {
-    tcp_read_allocation_done(tcp, GRPC_ERROR_NONE);
+  if (tcp->read_slices->length < GRPC_TCP_DEFAULT_READ_SLICE_SIZE) {
+    grpc_slice_buffer_add_indexed(
+        tcp->read_slices, GRPC_SLICE_MALLOC(GRPC_TCP_DEFAULT_READ_SLICE_SIZE));
   }
+  /* slices[0] should always exist here since we just added it if it did not */
+  char* buffer = reinterpret_cast<char*>(
+      GRPC_SLICE_START_PTR(tcp->read_slices->slices[0]));
+  size_t len = GRPC_SLICE_LENGTH(tcp->read_slices->slices[0]);
+  grpc_custom_socket_vtable->read(tcp->socket, buffer, len,
+                                  custom_read_callback);
 }
 
 static void custom_write_callback(grpc_custom_socket* socket,
@@ -346,7 +321,6 @@ static grpc_endpoint_vtable vtable = {endpoint_read,
                                       endpoint_can_track_err};
 
 grpc_endpoint* custom_tcp_endpoint_create(grpc_custom_socket* socket,
-                                          grpc_slice_allocator* slice_allocator,
                                           const char* peer_string) {
   custom_tcp_endpoint* tcp = new custom_tcp_endpoint;
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
@@ -372,6 +346,5 @@ grpc_endpoint* custom_tcp_endpoint_create(grpc_custom_socket* socket,
     tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
   }
   tcp->shutting_down = false;
-  tcp->slice_allocator = slice_allocator;
   return &tcp->base;
 }

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

@@ -80,7 +80,6 @@ void grpc_custom_close_server_callback(grpc_tcp_listener* listener);
 
 /// Takes ownership of \a slice_allocator.
 grpc_endpoint* custom_tcp_endpoint_create(grpc_custom_socket* socket,
-                                          grpc_slice_allocator* slice_allocator,
                                           const char* peer_string);
 
 #endif /* GRPC_CORE_LIB_IOMGR_TCP_CUSTOM_H */

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/impl/codegen/grpc_types.h>
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -54,10 +56,11 @@
 #include "src/core/lib/iomgr/buffer_list.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/resource_quota.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/resource_quota/api.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
@@ -393,7 +396,8 @@ struct grpc_tcp {
   std::string peer_string;
   std::string local_address;
 
-  grpc_slice_allocator* slice_allocator;
+  grpc_core::MemoryOwner memory_owner;
+  grpc_core::MemoryAllocator::Reservation self_reservation;
 
   grpc_core::TracedBuffer* tb_head; /* List of traced buffers */
   gpr_mu tb_mu; /* Lock for access to list of traced buffers */
@@ -608,7 +612,6 @@ static void tcp_free(grpc_tcp* tcp) {
   grpc_fd_orphan(tcp->em_fd, tcp->release_fd_cb, tcp->release_fd,
                  "tcp_unref_orphan");
   grpc_slice_buffer_destroy_internal(&tcp->last_read_buffer);
-  grpc_slice_allocator_destroy(tcp->slice_allocator);
   /* The lock is not really necessary here, since all refs have been released */
   gpr_mu_lock(&tcp->tb_mu);
   grpc_core::TracedBuffer::Shutdown(
@@ -701,6 +704,8 @@ static void tcp_do_read(grpc_tcp* tcp) {
     iov[i].iov_len = GRPC_SLICE_LENGTH(tcp->incoming_buffer->slices[i]);
   }
 
+  GPR_ASSERT(tcp->incoming_buffer->length != 0);
+
   do {
     /* Assume there is something on the queue. If we receive TCP_INQ from
      * kernel, we will update this value, otherwise, we have to assume there is
@@ -787,7 +792,6 @@ static void tcp_do_read(grpc_tcp* tcp) {
 
     total_read_bytes += read_bytes;
     if (tcp->inq == 0 || total_read_bytes == tcp->incoming_buffer->length) {
-      /* We have filled incoming_buffer, and we cannot read any more. */
       break;
     }
 
@@ -827,36 +831,25 @@ static void tcp_do_read(grpc_tcp* tcp) {
   TCP_UNREF(tcp, "read");
 }
 
-static void tcp_read_allocation_done(void* tcpp, grpc_error_handle error) {
-  grpc_tcp* tcp = static_cast<grpc_tcp*>(tcpp);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    gpr_log(GPR_INFO, "TCP:%p read_allocation_done: %s", tcp,
-            grpc_error_std_string(error).c_str());
-  }
-  if (GPR_UNLIKELY(error != GRPC_ERROR_NONE)) {
-    grpc_slice_buffer_reset_and_unref_internal(tcp->incoming_buffer);
-    grpc_slice_buffer_reset_and_unref_internal(&tcp->last_read_buffer);
-    call_read_cb(tcp, GRPC_ERROR_REF(error));
-    TCP_UNREF(tcp, "read");
-  } else {
-    tcp_do_read(tcp);
-  }
-}
-
 static void tcp_continue_read(grpc_tcp* tcp) {
-  /* Wait for allocation only when there is no buffer left. */
   if (tcp->incoming_buffer->length == 0 &&
       tcp->incoming_buffer->count < MAX_READ_IOVEC) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-      gpr_log(GPR_INFO, "TCP:%p alloc_slices", tcp);
-    }
-    if (GPR_UNLIKELY(!grpc_slice_allocator_allocate(
-            tcp->slice_allocator, tcp->target_length, 1,
-            grpc_slice_allocator_intent::kReadBuffer, tcp->incoming_buffer,
-            tcp_read_allocation_done, tcp))) {
-      // Wait for allocation.
-      return;
+      gpr_log(GPR_INFO,
+              "TCP:%p alloc_slices; min_chunk=%d max_chunk=%d target=%lf "
+              "buf_len=%" PRIdPTR,
+              tcp, tcp->min_read_chunk_size, tcp->max_read_chunk_size,
+              tcp->target_length, tcp->incoming_buffer->length);
     }
+    int target_length = static_cast<int>(tcp->target_length);
+    int extra_wanted =
+        target_length - static_cast<int>(tcp->incoming_buffer->length);
+    grpc_slice_buffer_add_indexed(
+        tcp->incoming_buffer,
+        tcp->memory_owner.MakeSlice(grpc_core::MemoryRequest(
+            tcp->min_read_chunk_size,
+            grpc_core::Clamp(extra_wanted, tcp->min_read_chunk_size,
+                             tcp->max_read_chunk_size))));
   }
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "TCP:%p do_read", tcp);
@@ -1669,8 +1662,7 @@ static const grpc_endpoint_vtable vtable = {tcp_read,
 
 grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
                                const grpc_channel_args* channel_args,
-                               const char* peer_string,
-                               grpc_slice_allocator* slice_allocator) {
+                               absl::string_view peer_string) {
   static constexpr bool kZerocpTxEnabledDefault = false;
   int tcp_read_chunk_size = GRPC_TCP_DEFAULT_READ_SLICE_SIZE;
   int tcp_max_read_chunk_size = 4 * 1024 * 1024;
@@ -1727,9 +1719,12 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
   grpc_tcp* tcp = new grpc_tcp(tcp_tx_zerocopy_max_simult_sends,
                                tcp_tx_zerocopy_send_bytes_thresh);
   tcp->base.vtable = &vtable;
-  tcp->peer_string = peer_string;
+  tcp->peer_string = std::string(peer_string);
   tcp->fd = grpc_fd_wrapped_fd(em_fd);
-  tcp->slice_allocator = slice_allocator;
+  tcp->memory_owner = grpc_core::ResourceQuotaFromChannelArgs(channel_args)
+                          ->memory_quota()
+                          ->CreateMemoryOwner(peer_string);
+  tcp->self_reservation = tcp->memory_owner.MakeReservation(sizeof(grpc_tcp));
   grpc_resolved_address resolved_local_addr;
   memset(&resolved_local_addr, 0, sizeof(resolved_local_addr));
   resolved_local_addr.len = sizeof(resolved_local_addr.addr);

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

@@ -36,15 +36,13 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/resource_quota.h"
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
 
 /// Create a tcp endpoint given a file desciptor and a read slice size.
 /// Takes ownership of \a fd. Takes ownership of the \a slice_allocator.
 grpc_endpoint* grpc_tcp_create(grpc_fd* fd, const grpc_channel_args* args,
-                               const char* peer_string,
-                               grpc_slice_allocator* slice_allocator);
+                               absl::string_view peer_string);
 
 /// Return the tcp endpoint's fd, or -1 if this is not available. Does not
 /// release the fd. Requires: \a ep must be a tcp endpoint.

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

@@ -22,12 +22,10 @@
 
 grpc_tcp_server_vtable* grpc_tcp_server_impl;
 
-grpc_error_handle grpc_tcp_server_create(
-    grpc_closure* shutdown_complete, const grpc_channel_args* args,
-    grpc_slice_allocator_factory* slice_allocator_factory,
-    grpc_tcp_server** server) {
-  return grpc_tcp_server_impl->create(shutdown_complete, args,
-                                      slice_allocator_factory, server);
+grpc_error_handle grpc_tcp_server_create(grpc_closure* shutdown_complete,
+                                         const grpc_channel_args* args,
+                                         grpc_tcp_server** server) {
+  return grpc_tcp_server_impl->create(shutdown_complete, args, server);
 }
 
 void grpc_tcp_server_start(grpc_tcp_server* server,

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

@@ -63,10 +63,9 @@ class TcpServerFdHandler {
 }  // namespace grpc_core
 
 typedef struct grpc_tcp_server_vtable {
-  grpc_error_handle (*create)(
-      grpc_closure* shutdown_complete, const grpc_channel_args* args,
-      grpc_slice_allocator_factory* slice_allocator_factory,
-      grpc_tcp_server** server);
+  grpc_error_handle (*create)(grpc_closure* shutdown_complete,
+                              const grpc_channel_args* args,
+                              grpc_tcp_server** server);
   void (*start)(grpc_tcp_server* server,
                 const std::vector<grpc_pollset*>* pollsets,
                 grpc_tcp_server_cb on_accept_cb, void* cb_arg);
@@ -87,10 +86,9 @@ typedef struct grpc_tcp_server_vtable {
    If shutdown_complete is not NULL, it will be used by
    grpc_tcp_server_unref() when the ref count reaches zero.
    Takes ownership of the slice_allocator_factory. */
-grpc_error_handle grpc_tcp_server_create(
-    grpc_closure* shutdown_complete, const grpc_channel_args* args,
-    grpc_slice_allocator_factory* slice_allocator_factory,
-    grpc_tcp_server** server);
+grpc_error_handle grpc_tcp_server_create(grpc_closure* shutdown_complete,
+                                         const grpc_channel_args* args,
+                                         grpc_tcp_server** server);
 
 /* Start listening to bound ports */
 void grpc_tcp_server_start(grpc_tcp_server* server,

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

@@ -76,16 +76,12 @@ struct grpc_tcp_server {
 
   bool shutdown;
   bool so_reuseport;
-
-  grpc_slice_allocator_factory* slice_allocator_factory;
 };
 
-static grpc_error_handle tcp_server_create(
-    grpc_closure* shutdown_complete, const grpc_channel_args* args,
-    grpc_slice_allocator_factory* slice_allocator_factory,
-    grpc_tcp_server** server) {
-  grpc_tcp_server* s =
-      static_cast<grpc_tcp_server*>(gpr_malloc(sizeof(grpc_tcp_server)));
+static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
+                                           const grpc_channel_args* args,
+                                           grpc_tcp_server** server) {
+  grpc_tcp_server* s = new grpc_tcp_server();
   s->so_reuseport =
       grpc_channel_args_find_bool(args, GRPC_ARG_ALLOW_REUSEPORT, true);
   gpr_ref_init(&s->refs, 1);
@@ -98,7 +94,6 @@ static grpc_error_handle tcp_server_create(
   s->shutdown_starting.tail = nullptr;
   s->shutdown_complete = shutdown_complete;
   s->shutdown = false;
-  s->slice_allocator_factory = slice_allocator_factory;
   *server = s;
   return GRPC_ERROR_NONE;
 }
@@ -128,7 +123,6 @@ static void finish_shutdown(grpc_tcp_server* s) {
     sp->next = nullptr;
     gpr_free(sp);
   }
-  grpc_slice_allocator_factory_destroy(s->slice_allocator_factory);
   gpr_free(s);
 }
 
@@ -219,11 +213,7 @@ static void finish_accept(grpc_tcp_listener* sp, grpc_custom_socket* socket) {
     gpr_log(GPR_INFO, "SERVER_CONNECT: %p accepted connection: %s", sp->server,
             peer_name_string.c_str());
   }
-  ep = custom_tcp_endpoint_create(
-      socket,
-      grpc_slice_allocator_factory_create_slice_allocator(
-          sp->server->slice_allocator_factory, peer_name_string),
-      peer_name_string.c_str());
+  ep = custom_tcp_endpoint_create(socket, peer_name_string.c_str());
   acceptor->from_server = sp->server;
   acceptor->port_index = sp->port_index;
   acceptor->fd_index = 0;

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

@@ -59,12 +59,12 @@
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/resource_quota/api.h"
 
-static grpc_error_handle tcp_server_create(
-    grpc_closure* shutdown_complete, const grpc_channel_args* args,
-    grpc_slice_allocator_factory* slice_allocator_factory,
-    grpc_tcp_server** server) {
-  grpc_tcp_server* s = grpc_core::Zalloc<grpc_tcp_server>();
+static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
+                                           const grpc_channel_args* args,
+                                           grpc_tcp_server** server) {
+  grpc_tcp_server* s = new grpc_tcp_server;
   s->so_reuseport = grpc_is_socket_reuse_port_supported();
   s->expand_wildcard_addrs = false;
   for (size_t i = 0; i < (args == nullptr ? 0 : args->num_args); i++) {
@@ -74,7 +74,6 @@ static grpc_error_handle tcp_server_create(
                           (args->args[i].value.integer != 0);
       } else {
         gpr_free(s);
-        grpc_slice_allocator_factory_destroy(slice_allocator_factory);
         return GRPC_ERROR_CREATE_FROM_STATIC_STRING(GRPC_ARG_ALLOW_REUSEPORT
                                                     " must be an integer");
       }
@@ -83,7 +82,6 @@ static grpc_error_handle tcp_server_create(
         s->expand_wildcard_addrs = (args->args[i].value.integer != 0);
       } else {
         gpr_free(s);
-        grpc_slice_allocator_factory_destroy(slice_allocator_factory);
         return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             GRPC_ARG_EXPAND_WILDCARD_ADDRS " must be an integer");
       }
@@ -104,7 +102,8 @@ static grpc_error_handle tcp_server_create(
   s->nports = 0;
   s->channel_args = grpc_channel_args_copy(args);
   s->fd_handler = nullptr;
-  s->slice_allocator_factory = slice_allocator_factory;
+  s->memory_quota =
+      grpc_core::ResourceQuotaFromChannelArgs(args)->memory_quota();
   gpr_atm_no_barrier_store(&s->next_pollset_to_assign, 0);
   *server = s;
   return GRPC_ERROR_NONE;
@@ -124,10 +123,9 @@ static void finish_shutdown(grpc_tcp_server* s) {
     s->head = sp->next;
     gpr_free(sp);
   }
-  grpc_slice_allocator_factory_destroy(s->slice_allocator_factory);
   grpc_channel_args_destroy(s->channel_args);
   delete s->fd_handler;
-  gpr_free(s);
+  delete s;
 }
 
 static void destroyed_port(void* server, grpc_error_handle /*error*/) {
@@ -222,6 +220,12 @@ static void on_read(void* arg, grpc_error_handle err) {
       }
     }
 
+    if (sp->server->memory_quota->IsMemoryPressureHigh()) {
+      gpr_log(GPR_INFO, "Drop incoming connection: high memory pressure");
+      close(fd);
+      continue;
+    }
+
     /* For UNIX sockets, the accept call might not fill up the member sun_path
      * of sockaddr_un, so explicitly call getsockname to get it. */
     if (grpc_is_unix_socket(&addr)) {
@@ -268,11 +272,7 @@ static void on_read(void* arg, grpc_error_handle err) {
     acceptor->external_connection = false;
     sp->server->on_accept_cb(
         sp->server->on_accept_cb_arg,
-        grpc_tcp_create(fdobj, sp->server->channel_args, addr_str.c_str(),
-                        grpc_slice_allocator_factory_create_slice_allocator(
-                            sp->server->slice_allocator_factory,
-                            absl::StrCat("tcp_server_posix:", addr_str),
-                            sp->server->channel_args)),
+        grpc_tcp_create(fdobj, sp->server->channel_args, addr_str),
         read_notifier_pollset, acceptor);
   }
 
@@ -615,13 +615,9 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
     acceptor->external_connection = true;
     acceptor->listener_fd = listener_fd;
     acceptor->pending_data = buf;
-    s_->on_accept_cb(
-        s_->on_accept_cb_arg,
-        grpc_tcp_create(
-            fdobj, s_->channel_args, addr_str.c_str(),
-            grpc_slice_allocator_factory_create_slice_allocator(
-                s_->slice_allocator_factory, addr_str, s_->channel_args)),
-        read_notifier_pollset, acceptor);
+    s_->on_accept_cb(s_->on_accept_cb_arg,
+                     grpc_tcp_create(fdobj, s_->channel_args, addr_str),
+                     read_notifier_pollset, acceptor);
   }
 
  private:

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

@@ -25,6 +25,7 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
 
 /* one listening port */
 typedef struct grpc_tcp_listener {
@@ -52,51 +53,51 @@ typedef struct grpc_tcp_listener {
 struct grpc_tcp_server {
   gpr_refcount refs;
   /* Called whenever accept() succeeds on a server port. */
-  grpc_tcp_server_cb on_accept_cb;
-  void* on_accept_cb_arg;
+  grpc_tcp_server_cb on_accept_cb = nullptr;
+  void* on_accept_cb_arg = nullptr;
 
   gpr_mu mu;
 
   /* active port count: how many ports are actually still listening */
-  size_t active_ports;
+  size_t active_ports = 0;
   /* destroyed port count: how many ports are completely destroyed */
-  size_t destroyed_ports;
+  size_t destroyed_ports = 0;
 
   /* is this server shutting down? */
-  bool shutdown;
+  bool shutdown = false;
   /* have listeners been shutdown? */
-  bool shutdown_listeners;
+  bool shutdown_listeners = false;
   /* use SO_REUSEPORT */
-  bool so_reuseport;
+  bool so_reuseport = false;
   /* expand wildcard addresses to a list of all local addresses */
-  bool expand_wildcard_addrs;
+  bool expand_wildcard_addrs = false;
 
   /* linked list of server ports */
-  grpc_tcp_listener* head;
-  grpc_tcp_listener* tail;
-  unsigned nports;
+  grpc_tcp_listener* head = nullptr;
+  grpc_tcp_listener* tail = nullptr;
+  unsigned nports = 0;
 
   /* List of closures passed to shutdown_starting_add(). */
-  grpc_closure_list shutdown_starting;
+  grpc_closure_list shutdown_starting{nullptr, nullptr};
 
   /* shutdown callback */
-  grpc_closure* shutdown_complete;
+  grpc_closure* shutdown_complete = nullptr;
 
   /* all pollsets interested in new connections. The object pointed at is not
    * owned by this struct */
-  const std::vector<grpc_pollset*>* pollsets;
+  const std::vector<grpc_pollset*>* pollsets = nullptr;
 
   /* next pollset to assign a channel to */
-  gpr_atm next_pollset_to_assign;
+  gpr_atm next_pollset_to_assign = 0;
 
   /* channel args for this server */
-  grpc_channel_args* channel_args;
+  grpc_channel_args* channel_args = nullptr;
 
   /* a handler for external connections, owned */
-  grpc_core::TcpServerFdHandler* fd_handler;
+  grpc_core::TcpServerFdHandler* fd_handler = nullptr;
 
   /* used to create slice allocators for endpoints, owned */
-  grpc_slice_allocator_factory* slice_allocator_factory;
+  grpc_core::MemoryQuotaRefPtr memory_quota;
 };
 
 /* If successful, add a listener to \a s for \a addr, set \a dsmode for the

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

@@ -96,15 +96,13 @@ struct grpc_tcp_server {
   grpc_closure* shutdown_complete;
 
   grpc_channel_args* channel_args;
-  grpc_slice_allocator_factory* slice_allocator_factory;
 };
 
 /* Public function. Allocates the proper data structures to hold a
    grpc_tcp_server. */
-static grpc_error_handle tcp_server_create(
-    grpc_closure* shutdown_complete, const grpc_channel_args* args,
-    grpc_slice_allocator_factory* slice_allocator_factory,
-    grpc_tcp_server** server) {
+static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
+                                           const grpc_channel_args* args,
+                                           grpc_tcp_server** server) {
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
   s->channel_args = grpc_channel_args_copy(args);
   gpr_ref_init(&s->refs, 1);
@@ -117,7 +115,6 @@ static grpc_error_handle tcp_server_create(
   s->shutdown_starting.head = NULL;
   s->shutdown_starting.tail = NULL;
   s->shutdown_complete = shutdown_complete;
-  s->slice_allocator_factory = slice_allocator_factory;
   *server = s;
   return GRPC_ERROR_NONE;
 }
@@ -168,7 +165,6 @@ static void tcp_server_shutdown_starting_add(grpc_tcp_server* s,
 static void tcp_server_destroy(grpc_tcp_server* s) {
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
-  grpc_slice_allocator_factory_destroy(s->slice_allocator_factory);
   /* First, shutdown all fd's. This will queue abortion calls for all
      of the pending accepts due to the normal operation mechanism. */
   if (s->active_ports == 0) {
@@ -358,11 +354,8 @@ static void on_accept(void* arg, grpc_error_handle error) {
         gpr_free(utf8_message);
       }
       std::string fd_name = absl::StrCat("tcp_server:", peer_name_string);
-      ep = grpc_tcp_create(
-          grpc_winsocket_create(sock, fd_name.c_str()),
-          sp->server->channel_args, peer_name_string.c_str(),
-          grpc_slice_allocator_factory_create_slice_allocator(
-              sp->server->slice_allocator_factory, peer_name_string));
+      ep = grpc_tcp_create(grpc_winsocket_create(sock, fd_name.c_str()),
+                           sp->server->channel_args, peer_name_string);
     } else {
       closesocket(sock);
     }

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

@@ -116,8 +116,6 @@ typedef struct grpc_tcp {
   grpc_slice_buffer* write_slices;
   grpc_slice_buffer* read_slices;
 
-  grpc_slice_allocator* slice_allocator;
-
   /* The IO Completion Port runs from another thread. We need some mechanism
      to protect ourselves when requesting a shutdown. */
   gpr_mu mu;
@@ -132,7 +130,6 @@ static void tcp_free(grpc_tcp* tcp) {
   grpc_winsocket_destroy(tcp->socket);
   gpr_mu_destroy(&tcp->mu);
   grpc_slice_buffer_destroy_internal(&tcp->last_read_buffer);
-  grpc_slice_allocator_destroy(tcp->slice_allocator);
   if (tcp->shutting_down) GRPC_ERROR_UNREF(tcp->shutdown_error);
   delete tcp;
 }
@@ -502,8 +499,7 @@ static grpc_endpoint_vtable vtable = {win_read,
 
 grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
                                grpc_channel_args* channel_args,
-                               const char* peer_string,
-                               grpc_slice_allocator* slice_allocator) {
+                               absl::string_view peer_string) {
   grpc_tcp* tcp = new grpc_tcp;
   memset(tcp, 0, sizeof(grpc_tcp));
   tcp->base.vtable = &vtable;
@@ -521,9 +517,8 @@ grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
   } else {
     tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
   }
-  tcp->peer_string = peer_string;
+  tcp->peer_string = std::string(peer_string);
   grpc_slice_buffer_init(&tcp->last_read_buffer);
-  tcp->slice_allocator = slice_allocator;
   return &tcp->base;
 }
 

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

@@ -42,8 +42,7 @@
  */
 grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
                                grpc_channel_args* channel_args,
-                               const char* peer_string,
-                               grpc_slice_allocator* slice_allocator);
+                               absl::string_view peer_string);
 
 grpc_error_handle grpc_tcp_prepare_socket(SOCKET sock);
 

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

@@ -41,7 +41,7 @@ void grpc_create_socketpair_if_unix(int sv[2]) {
 }
 
 grpc_error_handle grpc_resolve_unix_domain_address(
-    const char* name, grpc_resolved_addresses** addresses) {
+    absl::string_view name, grpc_resolved_addresses** addresses) {
   *addresses = static_cast<grpc_resolved_addresses*>(
       gpr_malloc(sizeof(grpc_resolved_addresses)));
   (*addresses)->naddrs = 1;

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

@@ -33,7 +33,7 @@
 void grpc_create_socketpair_if_unix(int sv[2]);
 
 grpc_error_handle grpc_resolve_unix_domain_address(
-    const char* name, grpc_resolved_addresses** addresses);
+    absl::string_view name, grpc_resolved_addresses** addresses);
 
 grpc_error_handle grpc_resolve_unix_abstract_domain_address(
     absl::string_view name, grpc_resolved_addresses** addresses);

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

@@ -34,7 +34,7 @@ void grpc_create_socketpair_if_unix(int /* sv */[2]) {
 }
 
 grpc_error_handle grpc_resolve_unix_domain_address(
-    const char* /* name */, grpc_resolved_addresses** addresses) {
+    absl::string_view /* name */, grpc_resolved_addresses** addresses) {
   *addresses = NULL;
   return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
       "Unix domain sockets are not supported on Windows");