grpc 1.28.0 → 1.42.0

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

@@ -25,11 +25,15 @@
 #include <stdint.h>
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_cat.h"
+
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.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"
@@ -39,11 +43,10 @@ grpc_core::TraceFlag grpc_resource_quota_trace(false, "resource_quota");
 #define MEMORY_USAGE_ESTIMATION_MAX 65536
 
 /* Internal linked list pointers for a resource user */
-typedef struct {
+struct grpc_resource_user_link {
   grpc_resource_user* next;
   grpc_resource_user* prev;
-} grpc_resource_user_link;
-
+};
 /* Resource users are kept in (potentially) several intrusive linked lists
    at once. These are the list names. */
 typedef enum {
@@ -119,7 +122,7 @@ struct grpc_resource_user {
   grpc_resource_user_link links[GRPC_RULIST_COUNT];
 
   /* The name of this resource user, for debugging/tracing */
-  char* name;
+  std::string name;
 };
 
 struct grpc_resource_quota {
@@ -130,7 +133,7 @@ struct grpc_resource_quota {
      scaled to the range [0..RESOURCE_USAGE_ESTIMATION_MAX] */
   gpr_atm memory_usage_estimation;
 
-  /* Master combiner lock: all activity on a quota executes under this combiner
+  /* Main combiner lock: all activity on a quota executes under this combiner
    * (so no mutex is needed for this data structure) */
   grpc_core::Combiner* combiner;
   /* Size of the resource quota */
@@ -182,7 +185,7 @@ struct grpc_resource_quota {
   /* Roots of all resource user lists */
   grpc_resource_user* roots[GRPC_RULIST_COUNT];
 
-  char* name;
+  std::string name;
 };
 
 static void ru_unref_by(grpc_resource_user* resource_user, gpr_atm amount);
@@ -274,7 +277,7 @@ static bool rq_reclaim_from_per_user_free_pool(
     grpc_resource_quota* resource_quota);
 static bool rq_reclaim(grpc_resource_quota* resource_quota, bool destructive);
 
-static void rq_step(void* rq, grpc_error* /*error*/) {
+static void rq_step(void* rq, grpc_error_handle /*error*/) {
   grpc_resource_quota* resource_quota = static_cast<grpc_resource_quota*>(rq);
   resource_quota->step_scheduled = false;
   do {
@@ -302,11 +305,12 @@ static void rq_step_sched(grpc_resource_quota* resource_quota) {
 static void rq_update_estimate(grpc_resource_quota* resource_quota) {
   gpr_atm memory_usage_estimation = MEMORY_USAGE_ESTIMATION_MAX;
   if (resource_quota->size != 0) {
-    memory_usage_estimation =
-        GPR_CLAMP((gpr_atm)((1.0 - ((double)resource_quota->free_pool) /
-                                       ((double)resource_quota->size)) *
-                            MEMORY_USAGE_ESTIMATION_MAX),
-                  0, MEMORY_USAGE_ESTIMATION_MAX);
+    memory_usage_estimation = grpc_core::Clamp(
+        static_cast<gpr_atm>(
+            (1.0 - (static_cast<double>(resource_quota->free_pool)) /
+                       (static_cast<double>(resource_quota->size))) *
+            MEMORY_USAGE_ESTIMATION_MAX),
+        gpr_atm(0), gpr_atm(MEMORY_USAGE_ESTIMATION_MAX));
   }
   gpr_atm_no_barrier_store(&resource_quota->memory_usage_estimation,
                            memory_usage_estimation);
@@ -321,9 +325,9 @@ static bool rq_alloc(grpc_resource_quota* resource_quota) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
       gpr_log(GPR_INFO,
               "RQ: check allocation for user %p shutdown=%" PRIdPTR
-              " free_pool=%" PRId64,
+              " free_pool=%" PRId64 " outstanding_allocations=%" PRId64,
               resource_user, gpr_atm_no_barrier_load(&resource_user->shutdown),
-              resource_user->free_pool);
+              resource_user->free_pool, resource_user->outstanding_allocations);
     }
     if (gpr_atm_no_barrier_load(&resource_user->shutdown)) {
       resource_user->allocating = false;
@@ -335,7 +339,9 @@ static bool rq_alloc(grpc_resource_quota* resource_quota) {
       resource_user->free_pool += aborted_allocations;
       grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &resource_user->on_allocated);
       gpr_mu_unlock(&resource_user->mu);
-      ru_unref_by(resource_user, static_cast<gpr_atm>(aborted_allocations));
+      if (aborted_allocations > 0) {
+        ru_unref_by(resource_user, static_cast<gpr_atm>(aborted_allocations));
+      }
       continue;
     }
     if (resource_user->free_pool < 0 &&
@@ -348,13 +354,13 @@ static bool rq_alloc(grpc_resource_quota* resource_quota) {
         gpr_log(GPR_INFO,
                 "RQ %s %s: grant alloc %" PRId64
                 " bytes; rq_free_pool -> %" PRId64,
-                resource_quota->name, resource_user->name, amt,
+                resource_quota->name.c_str(), resource_user->name.c_str(), amt,
                 resource_quota->free_pool);
       }
     } else if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace) &&
                resource_user->free_pool >= 0) {
       gpr_log(GPR_INFO, "RQ %s %s: discard already satisfied alloc request",
-              resource_quota->name, resource_user->name);
+              resource_quota->name.c_str(), resource_user->name.c_str());
     }
     if (resource_user->free_pool >= 0) {
       resource_user->allocating = false;
@@ -387,7 +393,7 @@ static bool rq_reclaim_from_per_user_free_pool(
         gpr_log(GPR_INFO,
                 "RQ %s %s: reclaim_from_per_user_free_pool %" PRId64
                 " bytes; rq_free_pool -> %" PRId64,
-                resource_quota->name, resource_user->name, amt,
+                resource_quota->name.c_str(), resource_user->name.c_str(), amt,
                 resource_quota->free_pool);
       }
       gpr_mu_unlock(&resource_user->mu);
@@ -397,7 +403,7 @@ static bool rq_reclaim_from_per_user_free_pool(
         gpr_log(GPR_INFO,
                 "RQ %s %s: failed to reclaim_from_per_user_free_pool; "
                 "free_pool = %" PRId64 "; rq_free_pool = %" PRId64,
-                resource_quota->name, resource_user->name,
+                resource_quota->name.c_str(), resource_user->name.c_str(),
                 resource_user->free_pool, resource_quota->free_pool);
       }
       gpr_mu_unlock(&resource_user->mu);
@@ -414,8 +420,9 @@ static bool rq_reclaim(grpc_resource_quota* resource_quota, bool destructive) {
   grpc_resource_user* resource_user = rulist_pop_head(resource_quota, list);
   if (resource_user == nullptr) return false;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
-    gpr_log(GPR_INFO, "RQ %s %s: initiate %s reclamation", resource_quota->name,
-            resource_user->name, destructive ? "destructive" : "benign");
+    gpr_log(GPR_INFO, "RQ %s %s: initiate %s reclamation",
+            resource_quota->name.c_str(), resource_user->name.c_str(),
+            destructive ? "destructive" : "benign");
   }
   resource_quota->reclaiming = true;
   grpc_resource_quota_ref_internal(resource_quota);
@@ -479,7 +486,8 @@ static grpc_slice ru_slice_create(grpc_resource_user* resource_user,
  * the combiner
  */
 
-static void ru_allocate(void* ru, grpc_error* /*error*/) {
+// 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,
                    GRPC_RULIST_AWAITING_ALLOCATION)) {
@@ -488,7 +496,7 @@ static void ru_allocate(void* ru, grpc_error* /*error*/) {
   rulist_add_tail(resource_user, GRPC_RULIST_AWAITING_ALLOCATION);
 }
 
-static void ru_add_to_free_pool(void* ru, grpc_error* /*error*/) {
+static void ru_add_to_free_pool(void* ru, grpc_error_handle /*error*/) {
   grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (!rulist_empty(resource_user->resource_quota,
                     GRPC_RULIST_AWAITING_ALLOCATION) &&
@@ -513,7 +521,7 @@ static bool ru_post_reclaimer(grpc_resource_user* resource_user,
   return true;
 }
 
-static void ru_post_benign_reclaimer(void* ru, grpc_error* /*error*/) {
+static void ru_post_benign_reclaimer(void* ru, grpc_error_handle /*error*/) {
   grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (!ru_post_reclaimer(resource_user, false)) return;
   if (!rulist_empty(resource_user->resource_quota,
@@ -527,7 +535,8 @@ static void ru_post_benign_reclaimer(void* ru, grpc_error* /*error*/) {
   rulist_add_tail(resource_user, GRPC_RULIST_RECLAIMER_BENIGN);
 }
 
-static void ru_post_destructive_reclaimer(void* ru, grpc_error* /*error*/) {
+static void ru_post_destructive_reclaimer(void* ru,
+                                          grpc_error_handle /*error*/) {
   grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (!ru_post_reclaimer(resource_user, true)) return;
   if (!rulist_empty(resource_user->resource_quota,
@@ -543,7 +552,7 @@ static void ru_post_destructive_reclaimer(void* ru, grpc_error* /*error*/) {
   rulist_add_tail(resource_user, GRPC_RULIST_RECLAIMER_DESTRUCTIVE);
 }
 
-static void ru_shutdown(void* ru, grpc_error* /*error*/) {
+static void ru_shutdown(void* ru, grpc_error_handle /*error*/) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
     gpr_log(GPR_INFO, "RU shutdown %p", ru);
   }
@@ -563,7 +572,7 @@ static void ru_shutdown(void* ru, grpc_error* /*error*/) {
   gpr_mu_unlock(&resource_user->mu);
 }
 
-static void ru_destroy(void* ru, grpc_error* /*error*/) {
+static void ru_destroy(void* ru, grpc_error_handle /*error*/) {
   grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   GPR_ASSERT(gpr_atm_no_barrier_load(&resource_user->refs) == 0);
   // Free all the remaining thread quota
@@ -584,12 +593,14 @@ static void ru_destroy(void* ru, grpc_error* /*error*/) {
   }
   grpc_resource_quota_unref_internal(resource_user->resource_quota);
   gpr_mu_destroy(&resource_user->mu);
-  gpr_free(resource_user->name);
-  gpr_free(resource_user);
+  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,
@@ -597,9 +608,9 @@ static void ru_alloc_slices(
   }
 }
 
-static void ru_allocated_slices(void* arg, grpc_error* error) {
-  grpc_resource_user_slice_allocator* slice_allocator =
-      static_cast<grpc_resource_user_slice_allocator*>(arg);
+static void ru_allocated_slices(void* arg, grpc_error_handle error) {
+  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));
@@ -610,13 +621,12 @@ static void ru_allocated_slices(void* arg, grpc_error* error) {
  * combiner
  */
 
-typedef struct {
+struct rq_resize_args {
   int64_t size;
   grpc_resource_quota* resource_quota;
   grpc_closure closure;
-} rq_resize_args;
-
-static void rq_resize(void* args, grpc_error* /*error*/) {
+};
+static void rq_resize(void* args, grpc_error_handle /*error*/) {
   rq_resize_args* a = static_cast<rq_resize_args*>(args);
   int64_t delta = a->size - a->resource_quota->size;
   a->resource_quota->size += delta;
@@ -627,7 +637,7 @@ static void rq_resize(void* args, grpc_error* /*error*/) {
   gpr_free(a);
 }
 
-static void rq_reclamation_done(void* rq, grpc_error* /*error*/) {
+static void rq_reclamation_done(void* rq, grpc_error_handle /*error*/) {
   grpc_resource_quota* resource_quota = static_cast<grpc_resource_quota*>(rq);
   resource_quota->reclaiming = false;
   rq_step_sched(resource_quota);
@@ -640,8 +650,7 @@ static void rq_reclamation_done(void* rq, grpc_error* /*error*/) {
 
 /* Public API */
 grpc_resource_quota* grpc_resource_quota_create(const char* name) {
-  grpc_resource_quota* resource_quota =
-      static_cast<grpc_resource_quota*>(gpr_malloc(sizeof(*resource_quota)));
+  grpc_resource_quota* resource_quota = new grpc_resource_quota;
   gpr_ref_init(&resource_quota->refs, 1);
   resource_quota->combiner = grpc_combiner_create();
   resource_quota->free_pool = INT64_MAX;
@@ -655,10 +664,10 @@ grpc_resource_quota* grpc_resource_quota_create(const char* name) {
   resource_quota->reclaiming = false;
   gpr_atm_no_barrier_store(&resource_quota->memory_usage_estimation, 0);
   if (name != nullptr) {
-    resource_quota->name = gpr_strdup(name);
+    resource_quota->name = name;
   } else {
-    gpr_asprintf(&resource_quota->name, "anonymous_pool_%" PRIxPTR,
-                 (intptr_t)resource_quota);
+    resource_quota->name = absl::StrCat(
+        "anonymous_pool_", reinterpret_cast<intptr_t>(resource_quota));
   }
   GRPC_CLOSURE_INIT(&resource_quota->rq_step_closure, rq_step, resource_quota,
                     nullptr);
@@ -675,9 +684,8 @@ void grpc_resource_quota_unref_internal(grpc_resource_quota* resource_quota) {
     // No outstanding thread quota
     GPR_ASSERT(resource_quota->num_threads_allocated == 0);
     GRPC_COMBINER_UNREF(resource_quota->combiner, "resource_quota");
-    gpr_free(resource_quota->name);
     gpr_mu_destroy(&resource_quota->thread_count_mu);
-    gpr_free(resource_quota);
+    delete resource_quota;
   }
 }
 
@@ -722,7 +730,7 @@ void grpc_resource_quota_resize(grpc_resource_quota* resource_quota,
   a->resource_quota = grpc_resource_quota_ref_internal(resource_quota);
   a->size = static_cast<int64_t>(size);
   gpr_atm_no_barrier_store(&resource_quota->last_size,
-                           (gpr_atm)GPR_MIN((size_t)GPR_ATM_MAX, size));
+                           (gpr_atm)std::min((size_t)GPR_ATM_MAX, size));
   GRPC_CLOSURE_INIT(&a->closure, rq_resize, a, grpc_schedule_on_exec_ctx);
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, &a->closure, GRPC_ERROR_NONE);
 }
@@ -738,16 +746,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;
 }
@@ -761,7 +763,7 @@ static void rq_destroy(void* rq) {
   grpc_resource_quota_unref_internal(static_cast<grpc_resource_quota*>(rq));
 }
 
-static int rq_cmp(void* a, void* b) { return GPR_ICMP(a, b); }
+static int rq_cmp(void* a, void* b) { return grpc_core::QsortCompare(a, b); }
 
 const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable(void) {
   static const grpc_arg_pointer_vtable vtable = {rq_copy, rq_destroy, rq_cmp};
@@ -773,9 +775,8 @@ 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_user* resource_user =
-      static_cast<grpc_resource_user*>(gpr_malloc(sizeof(*resource_user)));
+    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);
   GRPC_CLOSURE_INIT(&resource_user->allocate_closure, &ru_allocate,
@@ -804,11 +805,15 @@ 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 = gpr_strdup(name);
+  if (!name.empty()) {
+    resource_user->name = std::string(name);
   } else {
-    gpr_asprintf(&resource_user->name, "anonymous_resource_user_%" PRIxPTR,
-                 (intptr_t)resource_user);
+    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;
 }
@@ -820,13 +825,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);
@@ -854,9 +868,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;
@@ -869,15 +884,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);
@@ -890,8 +906,8 @@ static bool resource_user_alloc_locked(grpc_resource_user* resource_user,
   resource_user->free_pool -= static_cast<int64_t>(size);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
     gpr_log(GPR_INFO, "RQ %s %s: alloc %" PRIdPTR "; free_pool -> %" PRId64,
-            resource_user->resource_quota->name, resource_user->name, size,
-            resource_user->free_pool);
+            resource_user->resource_quota->name.c_str(),
+            resource_user->name.c_str(), size, resource_user->free_pool);
   }
   if (GPR_LIKELY(resource_user->free_pool >= 0)) return true;
   // Slow path: We need to wait for the free pool to refill.
@@ -951,8 +967,8 @@ void grpc_resource_user_free(grpc_resource_user* resource_user, size_t size) {
   resource_user->free_pool += static_cast<int64_t>(size);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
     gpr_log(GPR_INFO, "RQ %s %s: free %" PRIdPTR "; free_pool -> %" PRId64,
-            resource_user->resource_quota->name, resource_user->name, size,
-            resource_user->free_pool);
+            resource_user->resource_quota->name.c_str(),
+            resource_user->name.c_str(), size, resource_user->free_pool);
   }
   bool is_bigger_than_zero = resource_user->free_pool > 0;
   if (is_bigger_than_zero && was_zero_or_negative &&
@@ -977,26 +993,78 @@ void grpc_resource_user_post_reclaimer(grpc_resource_user* resource_user,
 void grpc_resource_user_finish_reclamation(grpc_resource_user* resource_user) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
     gpr_log(GPR_INFO, "RQ %s %s: reclamation complete",
-            resource_user->resource_quota->name, resource_user->name);
+            resource_user->resource_quota->name.c_str(),
+            resource_user->name.c_str());
   }
   resource_user->resource_quota->combiner->Run(
       &resource_user->resource_quota->rq_reclamation_done_closure,
       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;
+}
+
+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>(grpc_core::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_resource_user_alloc_slices(
-    grpc_resource_user_slice_allocator* slice_allocator, size_t length,
-    size_t count, grpc_slice_buffer* dest) {
+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(
@@ -1004,12 +1072,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;
+}