grpc 1.39.0.pre1 → 1.41.0.pre2

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

@@ -18,9 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/iomgr_internal.h"
+
 #include <stddef.h>
 
-#include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/timer_manager.h"
 

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

@@ -22,14 +22,13 @@
 
 #ifdef GRPC_WINSOCK_SOCKET
 
-#include "src/core/lib/iomgr/sockaddr_windows.h"
-
 #include <grpc/support/log.h>
 
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset_windows.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/sockaddr_windows.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"

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

@@ -18,19 +18,19 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/port.h"
-
 #include "src/core/lib/iomgr/is_epollexclusive_available.h"
 
-#ifdef GRPC_LINUX_EPOLL_CREATE1
+#include "src/core/lib/iomgr/port.h"
 
-#include <grpc/support/log.h>
+#ifdef GRPC_LINUX_EPOLL_CREATE1
 
 #include <errno.h>
 #include <sys/epoll.h>
 #include <sys/eventfd.h>
 #include <unistd.h>
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/iomgr/sys_epoll_wrapper.h"
 
 /* This polling engine is only relevant on linux kernels supporting epoll() */

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

@@ -18,11 +18,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/polling_entity.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/iomgr/polling_entity.h"
-
 grpc_polling_entity grpc_polling_entity_create_from_pollset_set(
     grpc_pollset_set* pollset_set) {
   grpc_polling_entity pollent;

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

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/pollset_custom.h"
 
 #include <stddef.h>
 #include <string.h>
@@ -27,14 +27,13 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
 #include "src/core/lib/iomgr/pollset.h"
-#include "src/core/lib/iomgr/pollset_custom.h"
+#include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/timer.h"
 
-#include "src/core/lib/debug/trace.h"
-
 static grpc_custom_poller_vtable* poller_vtable;
 
 struct grpc_pollset {

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

@@ -21,10 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/error.h"
-
 #include <stddef.h>
 
+#include "src/core/lib/iomgr/error.h"
+
 typedef struct grpc_custom_poller_vtable {
   void (*init)();
   grpc_error* (*poll)(size_t timeout_ms);

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

@@ -18,9 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/port.h"
-
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/port.h"
 
 static grpc_pollset_set* pollset_set_create(void) {
   return reinterpret_cast<grpc_pollset_set*>(static_cast<intptr_t>(0xdeafbeef));

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

@@ -19,6 +19,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <stdint.h>
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_WINSOCK_SOCKET

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

@@ -20,11 +20,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#ifdef GRPC_UV
-#ifndef GRPC_CUSTOM_SOCKET
-#define GRPC_CUSTOM_SOCKET
-#endif
-#endif
 /* This needs to be separate from the other conditions because it needs to
  * apply to custom sockets too */
 #ifdef GPR_WINDOWS

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

@@ -23,6 +23,7 @@
 
 #include <grpc/impl/codegen/slice.h>
 #include <grpc/status.h>
+
 #include "src/core/lib/iomgr/error.h"
 
 // These are only used by the gRPC Python extensions.
@@ -43,4 +44,4 @@ inline int grpc_slice_buffer_length(grpc_slice_buffer* buffer, int i) {
   return GRPC_SLICE_LENGTH(buffer->slices[i]);
 }
 
-#endif
+#endif  // GRPC_CORE_LIB_IOMGR_PYTHON_UTIL_H

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

@@ -17,9 +17,10 @@
  */
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/resolve_address.h"
+
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
-#include "src/core/lib/iomgr/resolve_address.h"
 
 namespace grpc_core {
 const char* kDefaultSecurePort = "https";

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

@@ -25,10 +25,6 @@
 
 #include "src/core/lib/iomgr/port.h"
 
-#ifdef GRPC_UV
-#include <uv.h>
-#endif
-
 #ifdef GRPC_WINSOCK_SOCKET
 #include <ws2tcpip.h>
 #endif

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

@@ -93,14 +93,14 @@ static grpc_error_handle try_split_host_port(const char* name,
   /* parse name, splitting it into host and port parts */
   grpc_core::SplitHostPort(name, host, port);
   if (host->empty()) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrFormat("unparseable host:port: '%s'", name).c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrFormat("unparseable host:port: '%s'", name));
   }
   if (port->empty()) {
     // TODO(murgatroid99): add tests for this case
     if (default_port == nullptr) {
-      return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          absl::StrFormat("no port in name '%s'", name).c_str());
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+          absl::StrFormat("no port in name '%s'", name));
     }
     *port = default_port;
   }

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

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/port.h"
-
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 

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

@@ -21,10 +21,6 @@
 #include "src/core/lib/iomgr/port.h"
 #ifdef GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
 
-#include "src/core/lib/iomgr/sockaddr.h"
-
-#include "src/core/lib/iomgr/resolve_address.h"
-
 #include <string.h>
 #include <sys/types.h>
 
@@ -40,6 +36,8 @@
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 
 static grpc_error_handle posix_blocking_resolve_address(

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

@@ -21,10 +21,6 @@
 #include "src/core/lib/iomgr/port.h"
 #ifdef GRPC_WINSOCK_SOCKET
 
-#include "src/core/lib/iomgr/sockaddr.h"
-
-#include "src/core/lib/iomgr/resolve_address.h"
-
 #include <inttypes.h>
 #include <string.h>
 #include <sys/types.h>
@@ -46,6 +42,8 @@
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/sockaddr.h"
 
 struct request {
   char* name;
@@ -69,14 +67,14 @@ static grpc_error_handle windows_blocking_resolve_address(
   std::string port;
   grpc_core::SplitHostPort(name, &host, &port);
   if (host.empty()) {
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrFormat("unparseable host:port: '%s'", name).c_str());
+    error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrFormat("unparseable host:port: '%s'", name));
     goto done;
   }
   if (port.empty()) {
     if (default_port == NULL) {
-      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          absl::StrFormat("no port in name '%s'", name).c_str());
+      error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
+          absl::StrFormat("no port in name '%s'", name));
       goto done;
     }
     port = default_port;

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

@@ -33,6 +33,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -484,6 +485,7 @@ static grpc_slice ru_slice_create(grpc_resource_user* resource_user,
  * the combiner
  */
 
+// TODO(hork): rename all ru variables to resource_user
 static void ru_allocate(void* ru, grpc_error_handle /*error*/) {
   grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (rulist_empty(resource_user->resource_quota,
@@ -590,11 +592,14 @@ static void ru_destroy(void* ru, grpc_error_handle /*error*/) {
   }
   grpc_resource_quota_unref_internal(resource_user->resource_quota);
   gpr_mu_destroy(&resource_user->mu);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
+    gpr_log(GPR_INFO, "RU '%s' (%p) destroyed", resource_user->name.c_str(),
+            resource_user);
+  }
   delete resource_user;
 }
 
-static void ru_alloc_slices(
-    grpc_resource_user_slice_allocator* slice_allocator) {
+static void ru_alloc_slices(grpc_slice_allocator* slice_allocator) {
   for (size_t i = 0; i < slice_allocator->count; i++) {
     grpc_slice_buffer_add_indexed(
         slice_allocator->dest, ru_slice_create(slice_allocator->resource_user,
@@ -603,8 +608,8 @@ static void ru_alloc_slices(
 }
 
 static void ru_allocated_slices(void* arg, grpc_error_handle error) {
-  grpc_resource_user_slice_allocator* slice_allocator =
-      static_cast<grpc_resource_user_slice_allocator*>(arg);
+  grpc_slice_allocator* slice_allocator =
+      static_cast<grpc_slice_allocator*>(arg);
   if (error == GRPC_ERROR_NONE) ru_alloc_slices(slice_allocator);
   grpc_core::Closure::Run(DEBUG_LOCATION, &slice_allocator->on_done,
                           GRPC_ERROR_REF(error));
@@ -740,16 +745,10 @@ size_t grpc_resource_quota_peek_size(grpc_resource_quota* resource_quota) {
 
 grpc_resource_quota* grpc_resource_quota_from_channel_args(
     const grpc_channel_args* channel_args, bool create) {
-  for (size_t i = 0; i < channel_args->num_args; i++) {
-    if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) {
-      if (channel_args->args[i].type == GRPC_ARG_POINTER) {
-        return grpc_resource_quota_ref_internal(
-            static_cast<grpc_resource_quota*>(
-                channel_args->args[i].value.pointer.p));
-      } else {
-        gpr_log(GPR_DEBUG, GRPC_ARG_RESOURCE_QUOTA " should be a pointer");
-      }
-    }
+  auto* resource_quota = grpc_channel_args_find_pointer<grpc_resource_quota>(
+      channel_args, GRPC_ARG_RESOURCE_QUOTA);
+  if (resource_quota != nullptr) {
+    return grpc_resource_quota_ref_internal(resource_quota);
   }
   return create ? grpc_resource_quota_create(nullptr) : nullptr;
 }
@@ -775,7 +774,7 @@ const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable(void) {
  */
 
 grpc_resource_user* grpc_resource_user_create(
-    grpc_resource_quota* resource_quota, const char* name) {
+    grpc_resource_quota* resource_quota, absl::string_view name) {
   grpc_resource_user* resource_user = new grpc_resource_user;
   resource_user->resource_quota =
       grpc_resource_quota_ref_internal(resource_quota);
@@ -805,12 +804,16 @@ grpc_resource_user* grpc_resource_user_create(
   for (int i = 0; i < GRPC_RULIST_COUNT; i++) {
     resource_user->links[i].next = resource_user->links[i].prev = nullptr;
   }
-  if (name != nullptr) {
-    resource_user->name = name;
+  if (!name.empty()) {
+    resource_user->name = std::string(name);
   } else {
     resource_user->name = absl::StrCat(
         "anonymous_resource_user_", reinterpret_cast<intptr_t>(resource_user));
   }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
+    gpr_log(GPR_INFO, "RU '%s' (%p) created", resource_user->name.c_str(),
+            resource_user);
+  }
   return resource_user;
 }
 
@@ -821,13 +824,22 @@ grpc_resource_quota* grpc_resource_user_quota(
 
 static void ru_ref_by(grpc_resource_user* resource_user, gpr_atm amount) {
   GPR_ASSERT(amount > 0);
-  GPR_ASSERT(gpr_atm_no_barrier_fetch_add(&resource_user->refs, amount) != 0);
+  gpr_atm prior = gpr_atm_no_barrier_fetch_add(&resource_user->refs, amount);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
+    gpr_log(GPR_INFO, "RU '%s' (%p) reffing: %" PRIdPTR " -> %" PRIdPTR,
+            resource_user->name.c_str(), resource_user, prior, prior + amount);
+  }
+  GPR_ASSERT(prior != 0);
 }
 
 static void ru_unref_by(grpc_resource_user* resource_user, gpr_atm amount) {
   GPR_ASSERT(amount > 0);
   gpr_atm old = gpr_atm_full_fetch_add(&resource_user->refs, -amount);
   GPR_ASSERT(old >= amount);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
+    gpr_log(GPR_INFO, "RU '%s' (%p) unreffing: %" PRIdPTR " -> %" PRIdPTR,
+            resource_user->name.c_str(), resource_user, old, old - amount);
+  }
   if (old == amount) {
     resource_user->resource_quota->combiner->Run(
         &resource_user->destroy_closure, GRPC_ERROR_NONE);
@@ -855,9 +867,10 @@ bool grpc_resource_user_allocate_threads(grpc_resource_user* resource_user,
   GPR_ASSERT(thread_count >= 0);
   bool is_success = false;
   gpr_mu_lock(&resource_user->resource_quota->thread_count_mu);
-  grpc_resource_quota* rq = resource_user->resource_quota;
-  if (rq->num_threads_allocated + thread_count <= rq->max_threads) {
-    rq->num_threads_allocated += thread_count;
+  grpc_resource_quota* resource_quota = resource_user->resource_quota;
+  if (resource_quota->num_threads_allocated + thread_count <=
+      resource_quota->max_threads) {
+    resource_quota->num_threads_allocated += thread_count;
     gpr_atm_no_barrier_fetch_add(&resource_user->num_threads_allocated,
                                  thread_count);
     is_success = true;
@@ -870,15 +883,16 @@ void grpc_resource_user_free_threads(grpc_resource_user* resource_user,
                                      int thread_count) {
   GPR_ASSERT(thread_count >= 0);
   gpr_mu_lock(&resource_user->resource_quota->thread_count_mu);
-  grpc_resource_quota* rq = resource_user->resource_quota;
-  rq->num_threads_allocated -= thread_count;
+  grpc_resource_quota* resource_quota = resource_user->resource_quota;
+  resource_quota->num_threads_allocated -= thread_count;
   int old_count = static_cast<int>(gpr_atm_no_barrier_fetch_add(
       &resource_user->num_threads_allocated, -thread_count));
-  if (old_count < thread_count || rq->num_threads_allocated < 0) {
+  if (old_count < thread_count || resource_quota->num_threads_allocated < 0) {
     gpr_log(GPR_ERROR,
-            "Releasing more threads (%d) than currently allocated (rq threads: "
-            "%d, ru threads: %d)",
-            thread_count, rq->num_threads_allocated + thread_count, old_count);
+            "Releasing more threads (%d) than currently allocated "
+            "(resource_quota threads: %d, ru threads: %d)",
+            thread_count, resource_quota->num_threads_allocated + thread_count,
+            old_count);
     abort();
   }
   gpr_mu_unlock(&resource_user->resource_quota->thread_count_mu);
@@ -986,19 +1000,69 @@ void grpc_resource_user_finish_reclamation(grpc_resource_user* resource_user) {
       GRPC_ERROR_NONE);
 }
 
-void grpc_resource_user_slice_allocator_init(
-    grpc_resource_user_slice_allocator* slice_allocator,
-    grpc_resource_user* resource_user, grpc_iomgr_cb_func cb, void* p) {
+grpc_slice_allocator* grpc_slice_allocator_create(
+    grpc_resource_quota* resource_quota, absl::string_view name,
+    const grpc_channel_args* args) {
+  grpc_slice_allocator* slice_allocator = new grpc_slice_allocator;
+  slice_allocator->min_length = grpc_channel_args_find_integer(
+      args, GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE,
+      {GRPC_SLICE_ALLOCATOR_MIN_ALLOCATE_SIZE, -1, INT_MAX});
+  slice_allocator->max_length = grpc_channel_args_find_integer(
+      args, GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE,
+      {GRPC_SLICE_ALLOCATOR_MAX_ALLOCATE_SIZE, -1, INT_MAX});
+  slice_allocator->resource_user =
+      grpc_resource_user_create(resource_quota, name);
   GRPC_CLOSURE_INIT(&slice_allocator->on_allocated, ru_allocated_slices,
                     slice_allocator, grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&slice_allocator->on_done, cb, p,
-                    grpc_schedule_on_exec_ctx);
-  slice_allocator->resource_user = resource_user;
+  return slice_allocator;
+}
+
+void grpc_slice_allocator_destroy(grpc_slice_allocator* slice_allocator) {
+  ru_unref_by(slice_allocator->resource_user, 1);
+  delete slice_allocator;
 }
 
-bool grpc_resource_user_alloc_slices(
-    grpc_resource_user_slice_allocator* slice_allocator, size_t length,
-    size_t count, grpc_slice_buffer* dest) {
+static size_t grpc_slice_allocator_adjust_allocation_length(
+    grpc_slice_allocator* slice_allocator, size_t requested_length,
+    grpc_slice_allocator_intent intent) {
+  if (intent == grpc_slice_allocator_intent::kDefault) {
+    return requested_length;
+  }
+  GPR_ASSERT(intent == grpc_slice_allocator_intent::kReadBuffer);
+  double pressure = grpc_resource_quota_get_memory_pressure(
+      slice_allocator->resource_user->resource_quota);
+  // Reduce allocation size proportional to the pressure > 80% usage.
+  size_t target =
+      requested_length * (pressure > 0.8 ? (1.0 - pressure) / 0.2 : 1.0);
+  // Target will be some multiple of 8 bytes, rounded up
+  target = ((static_cast<size_t> GPR_CLAMP(target, slice_allocator->min_length,
+                                           slice_allocator->max_length)) +
+            255) &
+           ~static_cast<size_t>(255);
+  // Don't use more than 1/16th of the overall resource quota for a single
+  // read alloc
+  size_t rqmax = grpc_resource_quota_peek_size(
+      slice_allocator->resource_user->resource_quota);
+  if (target > rqmax / 16 && rqmax > 1024) {
+    target = rqmax / 16;
+  }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
+    gpr_log(
+        GPR_INFO,
+        "SliceAllocator(%p) requested %zu bytes for (%s) intent, adjusted "
+        "allocation size to %zu",
+        slice_allocator, requested_length,
+        intent == grpc_slice_allocator_intent::kDefault ? "default" : "read",
+        target);
+  }
+  return target;
+}
+
+bool grpc_slice_allocator_allocate(grpc_slice_allocator* slice_allocator,
+                                   size_t length, size_t count,
+                                   grpc_slice_allocator_intent intent,
+                                   grpc_slice_buffer* dest,
+                                   grpc_iomgr_cb_func cb, void* p) {
   if (GPR_UNLIKELY(
           gpr_atm_no_barrier_load(&slice_allocator->resource_user->shutdown))) {
     grpc_core::ExecCtx::Run(
@@ -1006,12 +1070,35 @@ bool grpc_resource_user_alloc_slices(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resource user shutdown"));
     return false;
   }
-  slice_allocator->length = length;
+  GRPC_CLOSURE_INIT(&slice_allocator->on_done, cb, p,
+                    grpc_schedule_on_exec_ctx);
+  slice_allocator->length = grpc_slice_allocator_adjust_allocation_length(
+      slice_allocator, length, intent);
   slice_allocator->count = count;
   slice_allocator->dest = dest;
-  const bool ret =
-      grpc_resource_user_alloc(slice_allocator->resource_user, count * length,
-                               &slice_allocator->on_allocated);
+  const bool ret = grpc_resource_user_alloc(slice_allocator->resource_user,
+                                            count * slice_allocator->length,
+                                            &slice_allocator->on_allocated);
   if (ret) ru_alloc_slices(slice_allocator);
   return ret;
 }
+
+grpc_slice_allocator_factory* grpc_slice_allocator_factory_create(
+    grpc_resource_quota* resource_quota) {
+  grpc_slice_allocator_factory* factory = new grpc_slice_allocator_factory;
+  factory->resource_quota = resource_quota;
+  return factory;
+}
+
+grpc_slice_allocator* grpc_slice_allocator_factory_create_slice_allocator(
+    grpc_slice_allocator_factory* slice_allocator_factory,
+    absl::string_view name, grpc_channel_args* args) {
+  return grpc_slice_allocator_create(slice_allocator_factory->resource_quota,
+                                     name, args);
+}
+
+void grpc_slice_allocator_factory_destroy(
+    grpc_slice_allocator_factory* slice_allocator_factory) {
+  grpc_resource_quota_unref_internal(slice_allocator_factory->resource_quota);
+  delete slice_allocator_factory;
+}

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

@@ -69,6 +69,8 @@ extern grpc_core::TraceFlag grpc_resource_quota_trace;
 // hard coding.
 constexpr size_t GRPC_RESOURCE_QUOTA_CALL_SIZE = 15 * 1024;
 constexpr size_t GRPC_RESOURCE_QUOTA_CHANNEL_SIZE = 50 * 1024;
+constexpr size_t GRPC_SLICE_ALLOCATOR_MIN_ALLOCATE_SIZE = 256;
+constexpr size_t GRPC_SLICE_ALLOCATOR_MAX_ALLOCATE_SIZE = 4 * 1024 * 1024;
 
 grpc_resource_quota* grpc_resource_quota_ref_internal(
     grpc_resource_quota* resource_quota);
@@ -87,7 +89,7 @@ size_t grpc_resource_quota_peek_size(grpc_resource_quota* resource_quota);
 typedef struct grpc_resource_user grpc_resource_user;
 
 grpc_resource_user* grpc_resource_user_create(
-    grpc_resource_quota* resource_quota, const char* name);
+    grpc_resource_quota* resource_quota, absl::string_view name);
 
 /* Returns a borrowed reference to the underlying resource quota for this
    resource user. */
@@ -145,7 +147,7 @@ void grpc_resource_user_post_reclaimer(grpc_resource_user* resource_user,
 void grpc_resource_user_finish_reclamation(grpc_resource_user* resource_user);
 
 /* Helper to allocate slices from a resource user */
-typedef struct grpc_resource_user_slice_allocator {
+typedef struct grpc_slice_allocator {
   /* Closure for when a resource user allocation completes */
   grpc_closure on_allocated;
   /* Closure to call when slices have been allocated */
@@ -154,24 +156,71 @@ typedef struct grpc_resource_user_slice_allocator {
   size_t length;
   /* Number of slices to allocate on the current request */
   size_t count;
+  /* Minimum size to allocate under memory pressure. */
+  size_t min_length;
+  /* Maximum size that can be allocated. */
+  size_t max_length;
   /* Destination for slices to allocate on the current request */
   grpc_slice_buffer* dest;
   /* Parent resource user */
   grpc_resource_user* resource_user;
-} grpc_resource_user_slice_allocator;
-
-/* Initialize a slice allocator.
-   When an allocation is completed, calls \a cb with arg \p. */
-void grpc_resource_user_slice_allocator_init(
-    grpc_resource_user_slice_allocator* slice_allocator,
-    grpc_resource_user* resource_user, grpc_iomgr_cb_func cb, void* p);
-
-/* Allocate \a count slices of length \a length into \a dest. Only one request
-   can be outstanding at a time.
-   Returns whether the slice was allocated inline in the function. If true,
-   the \a slice_allocator->on_allocated callback will not be called. */
-bool grpc_resource_user_alloc_slices(
-    grpc_resource_user_slice_allocator* slice_allocator, size_t length,
-    size_t count, grpc_slice_buffer* dest) GRPC_MUST_USE_RESULT;
+} grpc_slice_allocator;
+
+/// Constructs a slice allocator using configuration from \a args.
+///
+/// Minimum and maximum limits for memory allocation size can be defined in
+/// \a args, and used to configure an allocator. See
+/// \a grpc_slice_allocator_allocate for details on how those values are used.
+///
+/// Caller is responsible for calling \a grpc_slice_allocator_destroy.
+grpc_slice_allocator* grpc_slice_allocator_create(
+    grpc_resource_quota* resource_quota, absl::string_view name,
+    const grpc_channel_args* args = nullptr);
+
+/* Cleans up after a slice_allocator. */
+void grpc_slice_allocator_destroy(grpc_slice_allocator* slice_allocator);
+
+enum class grpc_slice_allocator_intent {
+  kDefault,    // Default intent allocates exactly the memory required.
+  kReadBuffer  // ReadBuffer intent may return a smaller slice than requested if
+               // memory pressure is high.
+};
+
+/** Allocate \a count slices of length \a length into \a dest. Only one request
+   can be outstanding at a time. When an allocation is completed, calls \a cb
+   with arg \a p. Returns whether the slice was allocated inline in the
+   function. If true, the \a cb will not be called. The \a intent argument
+   allows allocation of smaller slices if memory pressure is high; the size is
+   implementation-dependent. */
+bool grpc_slice_allocator_allocate(grpc_slice_allocator* slice_allocator,
+                                   size_t length, size_t count,
+                                   grpc_slice_allocator_intent intent,
+                                   grpc_slice_buffer* dest,
+                                   grpc_iomgr_cb_func cb,
+                                   void* p) GRPC_MUST_USE_RESULT;
+
+/* Allows creation of slice_allocators (thus resource_users) without calling
+ * code having to understand resource_user concepts. */
+typedef struct grpc_slice_allocator_factory {
+  /* Parent resource quota */
+  grpc_resource_quota* resource_quota;
+} grpc_slice_allocator_factory;
+
+/* Constructs a slice allocator factory. Takes ownership of a ref on
+ * \a resource_quota from the caller. Caller is responsible for calling \a
+ * grpc_slice_allocator_factory_destroy. */
+grpc_slice_allocator_factory* grpc_slice_allocator_factory_create(
+    grpc_resource_quota* resource_quota);
+
+/* Cleans up after a slice_allocator. */
+void grpc_slice_allocator_factory_destroy(
+    grpc_slice_allocator_factory* slice_allocator_factory);
+
+/** A factory method to create and initialize a slice_allocator using the
+  factory's resource quota. \a name is the resulting resource_user name. \a args
+  are used to configure the \a slice_allocator */
+grpc_slice_allocator* grpc_slice_allocator_factory_create_slice_allocator(
+    grpc_slice_allocator_factory* slice_allocator_factory,
+    absl::string_view name, grpc_channel_args* args = nullptr);
 
 #endif /* GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H */