grpc 1.7.3 → 1.8.0

data/src/core/lib/iomgr/{resolve_address_windows.c → resolve_address_windows.cc}

@@ -23,6 +23,7 @@
 
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#include <inttypes.h>
 #include <string.h>
 #include <sys/types.h>
 
@@ -33,35 +34,35 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/thd.h>
 #include <grpc/support/time.h>
+#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/sockaddr_utils.h"
-#include "src/core/lib/support/block_annotate.h"
 #include "src/core/lib/support/string.h"
 
 typedef struct {
-  char *name;
-  char *default_port;
+  char* name;
+  char* default_port;
   grpc_closure request_closure;
-  grpc_closure *on_done;
-  grpc_resolved_addresses **addresses;
+  grpc_closure* on_done;
+  grpc_resolved_addresses** addresses;
 } request;
 
-static grpc_error *blocking_resolve_address_impl(
-    const char *name, const char *default_port,
-    grpc_resolved_addresses **addresses) {
+static grpc_error* blocking_resolve_address_impl(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses) {
   struct addrinfo hints;
   struct addrinfo *result = NULL, *resp;
-  char *host;
-  char *port;
+  char* host;
+  char* port;
   int s;
   size_t i;
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
 
   /* parse name, splitting it into host and port parts */
   gpr_split_host_port(name, &host, &port);
   if (host == NULL) {
-    char *msg;
+    char* msg;
     gpr_asprintf(&msg, "unparseable host:port: '%s'", name);
     error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
     gpr_free(msg);
@@ -69,7 +70,7 @@ static grpc_error *blocking_resolve_address_impl(
   }
   if (port == NULL) {
     if (default_port == NULL) {
-      char *msg;
+      char* msg;
       gpr_asprintf(&msg, "no port in name '%s'", name);
       error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
       gpr_free(msg);
@@ -86,20 +87,21 @@ static grpc_error *blocking_resolve_address_impl(
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
   s = getaddrinfo(host, port, &hints, &result);
-  GRPC_SCHEDULING_END_BLOCKING_REGION;
+  GRPC_SCHEDULING_END_BLOCKING_REGION_NO_EXEC_CTX;
   if (s != 0) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "getaddrinfo");
     goto done;
   }
 
   /* Success path: set addrs non-NULL, fill it in */
-  (*addresses) = gpr_malloc(sizeof(grpc_resolved_addresses));
+  (*addresses) =
+      (grpc_resolved_addresses*)gpr_malloc(sizeof(grpc_resolved_addresses));
   (*addresses)->naddrs = 0;
   for (resp = result; resp != NULL; resp = resp->ai_next) {
     (*addresses)->naddrs++;
   }
-  (*addresses)->addrs =
-      gpr_malloc(sizeof(grpc_resolved_address) * (*addresses)->naddrs);
+  (*addresses)->addrs = (grpc_resolved_address*)gpr_malloc(
+      sizeof(grpc_resolved_address) * (*addresses)->naddrs);
   i = 0;
   for (resp = result; resp != NULL; resp = resp->ai_next) {
     memcpy(&(*addresses)->addrs[i].addr, resp->ai_addr, resp->ai_addrlen);
@@ -109,7 +111,7 @@ static grpc_error *blocking_resolve_address_impl(
 
   {
     for (i = 0; i < (*addresses)->naddrs; i++) {
-      char *buf;
+      char* buf;
       grpc_sockaddr_to_string(&buf, &(*addresses)->addrs[i], 0);
       gpr_free(buf);
     }
@@ -124,15 +126,15 @@ done:
   return error;
 }
 
-grpc_error *(*grpc_blocking_resolve_address)(
-    const char *name, const char *default_port,
-    grpc_resolved_addresses **addresses) = blocking_resolve_address_impl;
+grpc_error* (*grpc_blocking_resolve_address)(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses) = blocking_resolve_address_impl;
 
 /* Callback to be passed to grpc_executor to asynch-ify
  * grpc_blocking_resolve_address */
-static void do_request_thread(grpc_exec_ctx *exec_ctx, void *rp,
-                              grpc_error *error) {
-  request *r = rp;
+static void do_request_thread(grpc_exec_ctx* exec_ctx, void* rp,
+                              grpc_error* error) {
+  request* r = (request*)rp;
   if (error == GRPC_ERROR_NONE) {
     error =
         grpc_blocking_resolve_address(r->name, r->default_port, r->addresses);
@@ -145,19 +147,19 @@ static void do_request_thread(grpc_exec_ctx *exec_ctx, void *rp,
   gpr_free(r);
 }
 
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses *addrs) {
+void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addrs) {
   if (addrs != NULL) {
     gpr_free(addrs->addrs);
   }
   gpr_free(addrs);
 }
 
-static void resolve_address_impl(grpc_exec_ctx *exec_ctx, const char *name,
-                                 const char *default_port,
-                                 grpc_pollset_set *interested_parties,
-                                 grpc_closure *on_done,
-                                 grpc_resolved_addresses **addresses) {
-  request *r = gpr_malloc(sizeof(request));
+static void resolve_address_impl(grpc_exec_ctx* exec_ctx, const char* name,
+                                 const char* default_port,
+                                 grpc_pollset_set* interested_parties,
+                                 grpc_closure* on_done,
+                                 grpc_resolved_addresses** addresses) {
+  request* r = (request*)gpr_malloc(sizeof(request));
   GRPC_CLOSURE_INIT(&r->request_closure, do_request_thread, r,
                     grpc_executor_scheduler(GRPC_EXECUTOR_SHORT));
   r->name = gpr_strdup(name);
@@ -168,8 +170,8 @@ static void resolve_address_impl(grpc_exec_ctx *exec_ctx, const char *name,
 }
 
 void (*grpc_resolve_address)(
-    grpc_exec_ctx *exec_ctx, const char *name, const char *default_port,
-    grpc_pollset_set *interested_parties, grpc_closure *on_done,
-    grpc_resolved_addresses **addresses) = resolve_address_impl;
+    grpc_exec_ctx* exec_ctx, const char* name, const char* default_port,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
+    grpc_resolved_addresses** addresses) = resolve_address_impl;
 
 #endif

data/src/core/lib/iomgr/{resource_quota.c → resource_quota.cc}

@@ -18,6 +18,7 @@
 
 #include "src/core/lib/iomgr/resource_quota.h"
 
+#include <inttypes.h>
 #include <limits.h>
 #include <stdint.h>
 #include <string.h>
@@ -30,15 +31,14 @@
 
 #include "src/core/lib/iomgr/combiner.h"
 
-grpc_tracer_flag grpc_resource_quota_trace =
-    GRPC_TRACER_INITIALIZER(false, "resource_quota");
+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 {
-  grpc_resource_user *next;
-  grpc_resource_user *prev;
+  grpc_resource_user* next;
+  grpc_resource_user* prev;
 } grpc_resource_user_link;
 
 /* Resource users are kept in (potentially) several intrusive linked lists
@@ -59,7 +59,7 @@ typedef enum {
 
 struct grpc_resource_user {
   /* The quota this resource user consumes from */
-  grpc_resource_quota *resource_quota;
+  grpc_resource_quota* resource_quota;
 
   /* Closure to schedule an allocation under the resource quota combiner lock */
   grpc_closure allocate_closure;
@@ -88,16 +88,18 @@ struct grpc_resource_user {
   grpc_closure_list on_allocated;
   /* True if we are currently trying to allocate from the quota, false if not */
   bool allocating;
+  /* How many bytes of allocations are outstanding */
+  int64_t outstanding_allocations;
   /* True if we are currently trying to add ourselves to the non-free quota
      list, false otherwise */
   bool added_to_free_pool;
 
   /* Reclaimers: index 0 is the benign reclaimer, 1 is the destructive reclaimer
    */
-  grpc_closure *reclaimers[2];
+  grpc_closure* reclaimers[2];
   /* Reclaimers just posted: once we're in the combiner lock, we'll move them
      to the array above */
-  grpc_closure *new_reclaimers[2];
+  grpc_closure* new_reclaimers[2];
   /* Trampoline closures to finish reclamation and re-enter the quota combiner
      lock */
   grpc_closure post_reclaimer_closure[2];
@@ -110,7 +112,7 @@ struct grpc_resource_user {
   grpc_resource_user_link links[GRPC_RULIST_COUNT];
 
   /* The name of this resource user, for debugging/tracing */
-  char *name;
+  char* name;
 };
 
 struct grpc_resource_quota {
@@ -123,7 +125,7 @@ struct grpc_resource_quota {
 
   /* Master combiner lock: all activity on a quota executes under this combiner
    * (so no mutex is needed for this data structure) */
-  grpc_combiner *combiner;
+  grpc_combiner* combiner;
   /* Size of the resource quota */
   int64_t size;
   /* Amount of free memory in the resource quota */
@@ -143,24 +145,27 @@ struct grpc_resource_quota {
   /* This is only really usable for debugging: it's always a stale pointer, but
      a stale pointer that might just be fresh enough to guide us to where the
      reclamation system is stuck */
-  grpc_closure *debug_only_last_initiated_reclaimer;
-  grpc_resource_user *debug_only_last_reclaimer_resource_user;
+  grpc_closure* debug_only_last_initiated_reclaimer;
+  grpc_resource_user* debug_only_last_reclaimer_resource_user;
 
   /* Roots of all resource user lists */
-  grpc_resource_user *roots[GRPC_RULIST_COUNT];
+  grpc_resource_user* roots[GRPC_RULIST_COUNT];
 
-  char *name;
+  char* name;
 };
 
+static void ru_unref_by(grpc_exec_ctx* exec_ctx,
+                        grpc_resource_user* resource_user, gpr_atm amount);
+
 /*******************************************************************************
  * list management
  */
 
-static void rulist_add_head(grpc_resource_user *resource_user,
+static void rulist_add_head(grpc_resource_user* resource_user,
                             grpc_rulist list) {
-  grpc_resource_quota *resource_quota = resource_user->resource_quota;
-  grpc_resource_user **root = &resource_quota->roots[list];
-  if (*root == NULL) {
+  grpc_resource_quota* resource_quota = resource_user->resource_quota;
+  grpc_resource_user** root = &resource_quota->roots[list];
+  if (*root == nullptr) {
     *root = resource_user;
     resource_user->links[list].next = resource_user->links[list].prev =
         resource_user;
@@ -173,11 +178,11 @@ static void rulist_add_head(grpc_resource_user *resource_user,
   }
 }
 
-static void rulist_add_tail(grpc_resource_user *resource_user,
+static void rulist_add_tail(grpc_resource_user* resource_user,
                             grpc_rulist list) {
-  grpc_resource_quota *resource_quota = resource_user->resource_quota;
-  grpc_resource_user **root = &resource_quota->roots[list];
-  if (*root == NULL) {
+  grpc_resource_quota* resource_quota = resource_user->resource_quota;
+  grpc_resource_user** root = &resource_quota->roots[list];
+  if (*root == nullptr) {
     *root = resource_user;
     resource_user->links[list].next = resource_user->links[list].prev =
         resource_user;
@@ -189,20 +194,20 @@ static void rulist_add_tail(grpc_resource_user *resource_user,
   }
 }
 
-static bool rulist_empty(grpc_resource_quota *resource_quota,
+static bool rulist_empty(grpc_resource_quota* resource_quota,
                          grpc_rulist list) {
-  return resource_quota->roots[list] == NULL;
+  return resource_quota->roots[list] == nullptr;
 }
 
-static grpc_resource_user *rulist_pop_head(grpc_resource_quota *resource_quota,
+static grpc_resource_user* rulist_pop_head(grpc_resource_quota* resource_quota,
                                            grpc_rulist list) {
-  grpc_resource_user **root = &resource_quota->roots[list];
-  grpc_resource_user *resource_user = *root;
-  if (resource_user == NULL) {
-    return NULL;
+  grpc_resource_user** root = &resource_quota->roots[list];
+  grpc_resource_user* resource_user = *root;
+  if (resource_user == nullptr) {
+    return nullptr;
   }
   if (resource_user->links[list].next == resource_user) {
-    *root = NULL;
+    *root = nullptr;
   } else {
     resource_user->links[list].next->links[list].prev =
         resource_user->links[list].prev;
@@ -210,39 +215,39 @@ static grpc_resource_user *rulist_pop_head(grpc_resource_quota *resource_quota,
         resource_user->links[list].next;
     *root = resource_user->links[list].next;
   }
-  resource_user->links[list].next = resource_user->links[list].prev = NULL;
+  resource_user->links[list].next = resource_user->links[list].prev = nullptr;
   return resource_user;
 }
 
-static void rulist_remove(grpc_resource_user *resource_user, grpc_rulist list) {
-  if (resource_user->links[list].next == NULL) return;
-  grpc_resource_quota *resource_quota = resource_user->resource_quota;
+static void rulist_remove(grpc_resource_user* resource_user, grpc_rulist list) {
+  if (resource_user->links[list].next == nullptr) return;
+  grpc_resource_quota* resource_quota = resource_user->resource_quota;
   if (resource_quota->roots[list] == resource_user) {
     resource_quota->roots[list] = resource_user->links[list].next;
     if (resource_quota->roots[list] == resource_user) {
-      resource_quota->roots[list] = NULL;
+      resource_quota->roots[list] = nullptr;
     }
   }
   resource_user->links[list].next->links[list].prev =
       resource_user->links[list].prev;
   resource_user->links[list].prev->links[list].next =
       resource_user->links[list].next;
-  resource_user->links[list].next = resource_user->links[list].prev = NULL;
+  resource_user->links[list].next = resource_user->links[list].prev = nullptr;
 }
 
 /*******************************************************************************
  * resource quota state machine
  */
 
-static bool rq_alloc(grpc_exec_ctx *exec_ctx,
-                     grpc_resource_quota *resource_quota);
+static bool rq_alloc(grpc_exec_ctx* exec_ctx,
+                     grpc_resource_quota* resource_quota);
 static bool rq_reclaim_from_per_user_free_pool(
-    grpc_exec_ctx *exec_ctx, grpc_resource_quota *resource_quota);
-static bool rq_reclaim(grpc_exec_ctx *exec_ctx,
-                       grpc_resource_quota *resource_quota, bool destructive);
+    grpc_exec_ctx* exec_ctx, grpc_resource_quota* resource_quota);
+static bool rq_reclaim(grpc_exec_ctx* exec_ctx,
+                       grpc_resource_quota* resource_quota, bool destructive);
 
-static void rq_step(grpc_exec_ctx *exec_ctx, void *rq, grpc_error *error) {
-  grpc_resource_quota *resource_quota = (grpc_resource_quota *)rq;
+static void rq_step(grpc_exec_ctx* exec_ctx, void* rq, grpc_error* error) {
+  grpc_resource_quota* resource_quota = (grpc_resource_quota*)rq;
   resource_quota->step_scheduled = false;
   do {
     if (rq_alloc(exec_ctx, resource_quota)) goto done;
@@ -256,8 +261,8 @@ done:
   grpc_resource_quota_unref_internal(exec_ctx, resource_quota);
 }
 
-static void rq_step_sched(grpc_exec_ctx *exec_ctx,
-                          grpc_resource_quota *resource_quota) {
+static void rq_step_sched(grpc_exec_ctx* exec_ctx,
+                          grpc_resource_quota* resource_quota) {
   if (resource_quota->step_scheduled) return;
   resource_quota->step_scheduled = true;
   grpc_resource_quota_ref_internal(resource_quota);
@@ -267,13 +272,12 @@ static void rq_step_sched(grpc_exec_ctx *exec_ctx,
 
 /* update the atomically available resource estimate - use no barriers since
    timeliness of delivery really doesn't matter much */
-static void rq_update_estimate(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)) *
+        GPR_CLAMP((gpr_atm)((1.0 - ((double)resource_quota->free_pool) /
+                                       ((double)resource_quota->size)) *
                             MEMORY_USAGE_ESTIMATION_MAX),
                   0, MEMORY_USAGE_ESTIMATION_MAX);
   }
@@ -282,31 +286,53 @@ static void rq_update_estimate(grpc_resource_quota *resource_quota) {
 }
 
 /* returns true if all allocations are completed */
-static bool rq_alloc(grpc_exec_ctx *exec_ctx,
-                     grpc_resource_quota *resource_quota) {
-  grpc_resource_user *resource_user;
+static bool rq_alloc(grpc_exec_ctx* exec_ctx,
+                     grpc_resource_quota* resource_quota) {
+  grpc_resource_user* resource_user;
   while ((resource_user = rulist_pop_head(resource_quota,
                                           GRPC_RULIST_AWAITING_ALLOCATION))) {
     gpr_mu_lock(&resource_user->mu);
+    if (grpc_resource_quota_trace.enabled()) {
+      gpr_log(GPR_DEBUG,
+              "RQ: check allocation for user %p shutdown=%" PRIdPTR
+              " free_pool=%" PRId64,
+              resource_user, gpr_atm_no_barrier_load(&resource_user->shutdown),
+              resource_user->free_pool);
+    }
+    if (gpr_atm_no_barrier_load(&resource_user->shutdown)) {
+      resource_user->allocating = false;
+      grpc_closure_list_fail_all(
+          &resource_user->on_allocated,
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resource user shutdown"));
+      int64_t aborted_allocations = resource_user->outstanding_allocations;
+      resource_user->outstanding_allocations = 0;
+      resource_user->free_pool += aborted_allocations;
+      GRPC_CLOSURE_LIST_SCHED(exec_ctx, &resource_user->on_allocated);
+      gpr_mu_unlock(&resource_user->mu);
+      ru_unref_by(exec_ctx, resource_user, (gpr_atm)aborted_allocations);
+      continue;
+    }
     if (resource_user->free_pool < 0 &&
         -resource_user->free_pool <= resource_quota->free_pool) {
       int64_t amt = -resource_user->free_pool;
       resource_user->free_pool = 0;
       resource_quota->free_pool -= amt;
       rq_update_estimate(resource_quota);
-      if (GRPC_TRACER_ON(grpc_resource_quota_trace)) {
-        gpr_log(GPR_DEBUG, "RQ %s %s: grant alloc %" PRId64
-                           " bytes; rq_free_pool -> %" PRId64,
+      if (grpc_resource_quota_trace.enabled()) {
+        gpr_log(GPR_DEBUG,
+                "RQ %s %s: grant alloc %" PRId64
+                " bytes; rq_free_pool -> %" PRId64,
                 resource_quota->name, resource_user->name, amt,
                 resource_quota->free_pool);
       }
-    } else if (GRPC_TRACER_ON(grpc_resource_quota_trace) &&
+    } else if (grpc_resource_quota_trace.enabled() &&
                resource_user->free_pool >= 0) {
       gpr_log(GPR_DEBUG, "RQ %s %s: discard already satisfied alloc request",
               resource_quota->name, resource_user->name);
     }
     if (resource_user->free_pool >= 0) {
       resource_user->allocating = false;
+      resource_user->outstanding_allocations = 0;
       GRPC_CLOSURE_LIST_SCHED(exec_ctx, &resource_user->on_allocated);
       gpr_mu_unlock(&resource_user->mu);
     } else {
@@ -320,8 +346,8 @@ static bool rq_alloc(grpc_exec_ctx *exec_ctx,
 
 /* returns true if any memory could be reclaimed from buffers */
 static bool rq_reclaim_from_per_user_free_pool(
-    grpc_exec_ctx *exec_ctx, grpc_resource_quota *resource_quota) {
-  grpc_resource_user *resource_user;
+    grpc_exec_ctx* exec_ctx, grpc_resource_quota* resource_quota) {
+  grpc_resource_user* resource_user;
   while ((resource_user = rulist_pop_head(resource_quota,
                                           GRPC_RULIST_NON_EMPTY_FREE_POOL))) {
     gpr_mu_lock(&resource_user->mu);
@@ -330,9 +356,10 @@ static bool rq_reclaim_from_per_user_free_pool(
       resource_user->free_pool = 0;
       resource_quota->free_pool += amt;
       rq_update_estimate(resource_quota);
-      if (GRPC_TRACER_ON(grpc_resource_quota_trace)) {
-        gpr_log(GPR_DEBUG, "RQ %s %s: reclaim_from_per_user_free_pool %" PRId64
-                           " bytes; rq_free_pool -> %" PRId64,
+      if (grpc_resource_quota_trace.enabled()) {
+        gpr_log(GPR_DEBUG,
+                "RQ %s %s: reclaim_from_per_user_free_pool %" PRId64
+                " bytes; rq_free_pool -> %" PRId64,
                 resource_quota->name, resource_user->name, amt,
                 resource_quota->free_pool);
       }
@@ -346,25 +373,25 @@ static bool rq_reclaim_from_per_user_free_pool(
 }
 
 /* returns true if reclamation is proceeding */
-static bool rq_reclaim(grpc_exec_ctx *exec_ctx,
-                       grpc_resource_quota *resource_quota, bool destructive) {
+static bool rq_reclaim(grpc_exec_ctx* exec_ctx,
+                       grpc_resource_quota* resource_quota, bool destructive) {
   if (resource_quota->reclaiming) return true;
   grpc_rulist list = destructive ? GRPC_RULIST_RECLAIMER_DESTRUCTIVE
                                  : GRPC_RULIST_RECLAIMER_BENIGN;
-  grpc_resource_user *resource_user = rulist_pop_head(resource_quota, list);
-  if (resource_user == NULL) return false;
-  if (GRPC_TRACER_ON(grpc_resource_quota_trace)) {
+  grpc_resource_user* resource_user = rulist_pop_head(resource_quota, list);
+  if (resource_user == nullptr) return false;
+  if (grpc_resource_quota_trace.enabled()) {
     gpr_log(GPR_DEBUG, "RQ %s %s: initiate %s reclamation",
             resource_quota->name, resource_user->name,
             destructive ? "destructive" : "benign");
   }
   resource_quota->reclaiming = true;
   grpc_resource_quota_ref_internal(resource_quota);
-  grpc_closure *c = resource_user->reclaimers[destructive];
+  grpc_closure* c = resource_user->reclaimers[destructive];
   GPR_ASSERT(c);
   resource_quota->debug_only_last_reclaimer_resource_user = resource_user;
   resource_quota->debug_only_last_initiated_reclaimer = c;
-  resource_user->reclaimers[destructive] = NULL;
+  resource_user->reclaimers[destructive] = nullptr;
   GRPC_CLOSURE_RUN(exec_ctx, c, GRPC_ERROR_NONE);
   return true;
 }
@@ -376,17 +403,17 @@ static bool rq_reclaim(grpc_exec_ctx *exec_ctx,
 typedef struct {
   grpc_slice_refcount base;
   gpr_refcount refs;
-  grpc_resource_user *resource_user;
+  grpc_resource_user* resource_user;
   size_t size;
 } ru_slice_refcount;
 
-static void ru_slice_ref(void *p) {
-  ru_slice_refcount *rc = (ru_slice_refcount *)p;
+static void ru_slice_ref(void* p) {
+  ru_slice_refcount* rc = (ru_slice_refcount*)p;
   gpr_ref(&rc->refs);
 }
 
-static void ru_slice_unref(grpc_exec_ctx *exec_ctx, void *p) {
-  ru_slice_refcount *rc = (ru_slice_refcount *)p;
+static void ru_slice_unref(grpc_exec_ctx* exec_ctx, void* p) {
+  ru_slice_refcount* rc = (ru_slice_refcount*)p;
   if (gpr_unref(&rc->refs)) {
     grpc_resource_user_free(exec_ctx, rc->resource_user, rc->size);
     gpr_free(rc);
@@ -397,10 +424,10 @@ static const grpc_slice_refcount_vtable ru_slice_vtable = {
     ru_slice_ref, ru_slice_unref, grpc_slice_default_eq_impl,
     grpc_slice_default_hash_impl};
 
-static grpc_slice ru_slice_create(grpc_resource_user *resource_user,
+static grpc_slice ru_slice_create(grpc_resource_user* resource_user,
                                   size_t size) {
-  ru_slice_refcount *rc =
-      (ru_slice_refcount *)gpr_malloc(sizeof(ru_slice_refcount) + size);
+  ru_slice_refcount* rc =
+      (ru_slice_refcount*)gpr_malloc(sizeof(ru_slice_refcount) + size);
   rc->base.vtable = &ru_slice_vtable;
   rc->base.sub_refcount = &rc->base;
   gpr_ref_init(&rc->refs, 1);
@@ -408,7 +435,7 @@ static grpc_slice ru_slice_create(grpc_resource_user *resource_user,
   rc->size = size;
   grpc_slice slice;
   slice.refcount = &rc->base;
-  slice.data.refcounted.bytes = (uint8_t *)(rc + 1);
+  slice.data.refcounted.bytes = (uint8_t*)(rc + 1);
   slice.data.refcounted.length = size;
   return slice;
 }
@@ -418,8 +445,8 @@ static grpc_slice ru_slice_create(grpc_resource_user *resource_user,
  * the combiner
  */
 
-static void ru_allocate(grpc_exec_ctx *exec_ctx, void *ru, grpc_error *error) {
-  grpc_resource_user *resource_user = (grpc_resource_user *)ru;
+static void ru_allocate(grpc_exec_ctx* exec_ctx, void* ru, grpc_error* error) {
+  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
   if (rulist_empty(resource_user->resource_quota,
                    GRPC_RULIST_AWAITING_ALLOCATION)) {
     rq_step_sched(exec_ctx, resource_user->resource_quota);
@@ -427,9 +454,9 @@ static void ru_allocate(grpc_exec_ctx *exec_ctx, void *ru, grpc_error *error) {
   rulist_add_tail(resource_user, GRPC_RULIST_AWAITING_ALLOCATION);
 }
 
-static void ru_add_to_free_pool(grpc_exec_ctx *exec_ctx, void *ru,
-                                grpc_error *error) {
-  grpc_resource_user *resource_user = (grpc_resource_user *)ru;
+static void ru_add_to_free_pool(grpc_exec_ctx* exec_ctx, void* ru,
+                                grpc_error* error) {
+  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
   if (!rulist_empty(resource_user->resource_quota,
                     GRPC_RULIST_AWAITING_ALLOCATION) &&
       rulist_empty(resource_user->resource_quota,
@@ -439,13 +466,13 @@ static void ru_add_to_free_pool(grpc_exec_ctx *exec_ctx, void *ru,
   rulist_add_tail(resource_user, GRPC_RULIST_NON_EMPTY_FREE_POOL);
 }
 
-static bool ru_post_reclaimer(grpc_exec_ctx *exec_ctx,
-                              grpc_resource_user *resource_user,
+static bool ru_post_reclaimer(grpc_exec_ctx* exec_ctx,
+                              grpc_resource_user* resource_user,
                               bool destructive) {
-  grpc_closure *closure = resource_user->new_reclaimers[destructive];
-  GPR_ASSERT(closure != NULL);
-  resource_user->new_reclaimers[destructive] = NULL;
-  GPR_ASSERT(resource_user->reclaimers[destructive] == NULL);
+  grpc_closure* closure = resource_user->new_reclaimers[destructive];
+  GPR_ASSERT(closure != nullptr);
+  resource_user->new_reclaimers[destructive] = nullptr;
+  GPR_ASSERT(resource_user->reclaimers[destructive] == nullptr);
   if (gpr_atm_acq_load(&resource_user->shutdown) > 0) {
     GRPC_CLOSURE_SCHED(exec_ctx, closure, GRPC_ERROR_CANCELLED);
     return false;
@@ -454,9 +481,9 @@ static bool ru_post_reclaimer(grpc_exec_ctx *exec_ctx,
   return true;
 }
 
-static void ru_post_benign_reclaimer(grpc_exec_ctx *exec_ctx, void *ru,
-                                     grpc_error *error) {
-  grpc_resource_user *resource_user = (grpc_resource_user *)ru;
+static void ru_post_benign_reclaimer(grpc_exec_ctx* exec_ctx, void* ru,
+                                     grpc_error* error) {
+  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
   if (!ru_post_reclaimer(exec_ctx, resource_user, false)) return;
   if (!rulist_empty(resource_user->resource_quota,
                     GRPC_RULIST_AWAITING_ALLOCATION) &&
@@ -469,9 +496,9 @@ static void ru_post_benign_reclaimer(grpc_exec_ctx *exec_ctx, void *ru,
   rulist_add_tail(resource_user, GRPC_RULIST_RECLAIMER_BENIGN);
 }
 
-static void ru_post_destructive_reclaimer(grpc_exec_ctx *exec_ctx, void *ru,
-                                          grpc_error *error) {
-  grpc_resource_user *resource_user = (grpc_resource_user *)ru;
+static void ru_post_destructive_reclaimer(grpc_exec_ctx* exec_ctx, void* ru,
+                                          grpc_error* error) {
+  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
   if (!ru_post_reclaimer(exec_ctx, resource_user, true)) return;
   if (!rulist_empty(resource_user->resource_quota,
                     GRPC_RULIST_AWAITING_ALLOCATION) &&
@@ -486,20 +513,26 @@ static void ru_post_destructive_reclaimer(grpc_exec_ctx *exec_ctx, void *ru,
   rulist_add_tail(resource_user, GRPC_RULIST_RECLAIMER_DESTRUCTIVE);
 }
 
-static void ru_shutdown(grpc_exec_ctx *exec_ctx, void *ru, grpc_error *error) {
-  grpc_resource_user *resource_user = (grpc_resource_user *)ru;
+static void ru_shutdown(grpc_exec_ctx* exec_ctx, void* ru, grpc_error* error) {
+  if (grpc_resource_quota_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "RU shutdown %p", ru);
+  }
+  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
   GRPC_CLOSURE_SCHED(exec_ctx, resource_user->reclaimers[0],
                      GRPC_ERROR_CANCELLED);
   GRPC_CLOSURE_SCHED(exec_ctx, resource_user->reclaimers[1],
                      GRPC_ERROR_CANCELLED);
-  resource_user->reclaimers[0] = NULL;
-  resource_user->reclaimers[1] = NULL;
+  resource_user->reclaimers[0] = nullptr;
+  resource_user->reclaimers[1] = nullptr;
   rulist_remove(resource_user, GRPC_RULIST_RECLAIMER_BENIGN);
   rulist_remove(resource_user, GRPC_RULIST_RECLAIMER_DESTRUCTIVE);
+  if (resource_user->allocating) {
+    rq_step_sched(exec_ctx, resource_user->resource_quota);
+  }
 }
 
-static void ru_destroy(grpc_exec_ctx *exec_ctx, void *ru, grpc_error *error) {
-  grpc_resource_user *resource_user = (grpc_resource_user *)ru;
+static void ru_destroy(grpc_exec_ctx* exec_ctx, void* ru, grpc_error* error) {
+  grpc_resource_user* resource_user = (grpc_resource_user*)ru;
   GPR_ASSERT(gpr_atm_no_barrier_load(&resource_user->refs) == 0);
   for (int i = 0; i < GRPC_RULIST_COUNT; i++) {
     rulist_remove(resource_user, (grpc_rulist)i);
@@ -518,10 +551,10 @@ static void ru_destroy(grpc_exec_ctx *exec_ctx, void *ru, grpc_error *error) {
   gpr_free(resource_user);
 }
 
-static void ru_allocated_slices(grpc_exec_ctx *exec_ctx, void *arg,
-                                grpc_error *error) {
-  grpc_resource_user_slice_allocator *slice_allocator =
-      (grpc_resource_user_slice_allocator *)arg;
+static void ru_allocated_slices(grpc_exec_ctx* exec_ctx, void* arg,
+                                grpc_error* error) {
+  grpc_resource_user_slice_allocator* slice_allocator =
+      (grpc_resource_user_slice_allocator*)arg;
   if (error == GRPC_ERROR_NONE) {
     for (size_t i = 0; i < slice_allocator->count; i++) {
       grpc_slice_buffer_add_indexed(
@@ -539,12 +572,12 @@ static void ru_allocated_slices(grpc_exec_ctx *exec_ctx, void *arg,
 
 typedef struct {
   int64_t size;
-  grpc_resource_quota *resource_quota;
+  grpc_resource_quota* resource_quota;
   grpc_closure closure;
 } rq_resize_args;
 
-static void rq_resize(grpc_exec_ctx *exec_ctx, void *args, grpc_error *error) {
-  rq_resize_args *a = (rq_resize_args *)args;
+static void rq_resize(grpc_exec_ctx* exec_ctx, void* args, grpc_error* error) {
+  rq_resize_args* a = (rq_resize_args*)args;
   int64_t delta = a->size - a->resource_quota->size;
   a->resource_quota->size += delta;
   a->resource_quota->free_pool += delta;
@@ -554,9 +587,9 @@ static void rq_resize(grpc_exec_ctx *exec_ctx, void *args, grpc_error *error) {
   gpr_free(a);
 }
 
-static void rq_reclamation_done(grpc_exec_ctx *exec_ctx, void *rq,
-                                grpc_error *error) {
-  grpc_resource_quota *resource_quota = (grpc_resource_quota *)rq;
+static void rq_reclamation_done(grpc_exec_ctx* exec_ctx, void* rq,
+                                grpc_error* error) {
+  grpc_resource_quota* resource_quota = (grpc_resource_quota*)rq;
   resource_quota->reclaiming = false;
   rq_step_sched(exec_ctx, resource_quota);
   grpc_resource_quota_unref_internal(exec_ctx, resource_quota);
@@ -567,9 +600,9 @@ static void rq_reclamation_done(grpc_exec_ctx *exec_ctx, void *rq,
  */
 
 /* Public API */
-grpc_resource_quota *grpc_resource_quota_create(const char *name) {
-  grpc_resource_quota *resource_quota =
-      (grpc_resource_quota *)gpr_malloc(sizeof(*resource_quota));
+grpc_resource_quota* grpc_resource_quota_create(const char* name) {
+  grpc_resource_quota* resource_quota =
+      (grpc_resource_quota*)gpr_malloc(sizeof(*resource_quota));
   gpr_ref_init(&resource_quota->refs, 1);
   resource_quota->combiner = grpc_combiner_create();
   resource_quota->free_pool = INT64_MAX;
@@ -578,7 +611,7 @@ grpc_resource_quota *grpc_resource_quota_create(const char *name) {
   resource_quota->step_scheduled = false;
   resource_quota->reclaiming = false;
   gpr_atm_no_barrier_store(&resource_quota->memory_usage_estimation, 0);
-  if (name != NULL) {
+  if (name != nullptr) {
     resource_quota->name = gpr_strdup(name);
   } else {
     gpr_asprintf(&resource_quota->name, "anonymous_pool_%" PRIxPTR,
@@ -590,13 +623,13 @@ grpc_resource_quota *grpc_resource_quota_create(const char *name) {
                     rq_reclamation_done, resource_quota,
                     grpc_combiner_scheduler(resource_quota->combiner));
   for (int i = 0; i < GRPC_RULIST_COUNT; i++) {
-    resource_quota->roots[i] = NULL;
+    resource_quota->roots[i] = nullptr;
   }
   return resource_quota;
 }
 
-void grpc_resource_quota_unref_internal(grpc_exec_ctx *exec_ctx,
-                                        grpc_resource_quota *resource_quota) {
+void grpc_resource_quota_unref_internal(grpc_exec_ctx* exec_ctx,
+                                        grpc_resource_quota* resource_quota) {
   if (gpr_unref(&resource_quota->refs)) {
     GRPC_COMBINER_UNREF(exec_ctx, resource_quota->combiner, "resource_quota");
     gpr_free(resource_quota->name);
@@ -605,35 +638,35 @@ void grpc_resource_quota_unref_internal(grpc_exec_ctx *exec_ctx,
 }
 
 /* Public API */
-void grpc_resource_quota_unref(grpc_resource_quota *resource_quota) {
+void grpc_resource_quota_unref(grpc_resource_quota* resource_quota) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_resource_quota_unref_internal(&exec_ctx, resource_quota);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-grpc_resource_quota *grpc_resource_quota_ref_internal(
-    grpc_resource_quota *resource_quota) {
+grpc_resource_quota* grpc_resource_quota_ref_internal(
+    grpc_resource_quota* resource_quota) {
   gpr_ref(&resource_quota->refs);
   return resource_quota;
 }
 
 /* Public API */
-void grpc_resource_quota_ref(grpc_resource_quota *resource_quota) {
+void grpc_resource_quota_ref(grpc_resource_quota* resource_quota) {
   grpc_resource_quota_ref_internal(resource_quota);
 }
 
 double grpc_resource_quota_get_memory_pressure(
-    grpc_resource_quota *resource_quota) {
+    grpc_resource_quota* resource_quota) {
   return ((double)(gpr_atm_no_barrier_load(
              &resource_quota->memory_usage_estimation))) /
          ((double)MEMORY_USAGE_ESTIMATION_MAX);
 }
 
 /* Public API */
-void grpc_resource_quota_resize(grpc_resource_quota *resource_quota,
+void grpc_resource_quota_resize(grpc_resource_quota* resource_quota,
                                 size_t size) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  rq_resize_args *a = (rq_resize_args *)gpr_malloc(sizeof(*a));
+  rq_resize_args* a = (rq_resize_args*)gpr_malloc(sizeof(*a));
   a->resource_quota = grpc_resource_quota_ref_internal(resource_quota);
   a->size = (int64_t)size;
   gpr_atm_no_barrier_store(&resource_quota->last_size,
@@ -643,7 +676,7 @@ void grpc_resource_quota_resize(grpc_resource_quota *resource_quota,
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-size_t grpc_resource_quota_peek_size(grpc_resource_quota *resource_quota) {
+size_t grpc_resource_quota_peek_size(grpc_resource_quota* resource_quota) {
   return (size_t)gpr_atm_no_barrier_load(&resource_quota->last_size);
 }
 
@@ -651,33 +684,33 @@ size_t grpc_resource_quota_peek_size(grpc_resource_quota *resource_quota) {
  * grpc_resource_user channel args api
  */
 
-grpc_resource_quota *grpc_resource_quota_from_channel_args(
-    const grpc_channel_args *channel_args) {
+grpc_resource_quota* grpc_resource_quota_from_channel_args(
+    const grpc_channel_args* channel_args) {
   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(
-            (grpc_resource_quota *)channel_args->args[i].value.pointer.p);
+            (grpc_resource_quota*)channel_args->args[i].value.pointer.p);
       } else {
         gpr_log(GPR_DEBUG, GRPC_ARG_RESOURCE_QUOTA " should be a pointer");
       }
     }
   }
-  return grpc_resource_quota_create(NULL);
+  return grpc_resource_quota_create(nullptr);
 }
 
-static void *rq_copy(void *rq) {
-  grpc_resource_quota_ref((grpc_resource_quota *)rq);
+static void* rq_copy(void* rq) {
+  grpc_resource_quota_ref((grpc_resource_quota*)rq);
   return rq;
 }
 
-static void rq_destroy(grpc_exec_ctx *exec_ctx, void *rq) {
-  grpc_resource_quota_unref_internal(exec_ctx, (grpc_resource_quota *)rq);
+static void rq_destroy(grpc_exec_ctx* exec_ctx, void* rq) {
+  grpc_resource_quota_unref_internal(exec_ctx, (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 GPR_ICMP(a, b); }
 
-const grpc_arg_pointer_vtable *grpc_resource_quota_arg_vtable(void) {
+const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable(void) {
   static const grpc_arg_pointer_vtable vtable = {rq_copy, rq_destroy, rq_cmp};
   return &vtable;
 }
@@ -686,10 +719,10 @@ const grpc_arg_pointer_vtable *grpc_resource_quota_arg_vtable(void) {
  * grpc_resource_user api
  */
 
-grpc_resource_user *grpc_resource_user_create(
-    grpc_resource_quota *resource_quota, const char *name) {
-  grpc_resource_user *resource_user =
-      (grpc_resource_user *)gpr_malloc(sizeof(*resource_user));
+grpc_resource_user* grpc_resource_user_create(
+    grpc_resource_quota* resource_quota, const char* name) {
+  grpc_resource_user* resource_user =
+      (grpc_resource_user*)gpr_malloc(sizeof(*resource_user));
   resource_user->resource_quota =
       grpc_resource_quota_ref_internal(resource_quota);
   GRPC_CLOSURE_INIT(&resource_user->allocate_closure, &ru_allocate,
@@ -713,14 +746,15 @@ grpc_resource_user *grpc_resource_user_create(
   grpc_closure_list_init(&resource_user->on_allocated);
   resource_user->allocating = false;
   resource_user->added_to_free_pool = false;
-  resource_user->reclaimers[0] = NULL;
-  resource_user->reclaimers[1] = NULL;
-  resource_user->new_reclaimers[0] = NULL;
-  resource_user->new_reclaimers[1] = NULL;
+  resource_user->reclaimers[0] = nullptr;
+  resource_user->reclaimers[1] = nullptr;
+  resource_user->new_reclaimers[0] = nullptr;
+  resource_user->new_reclaimers[1] = nullptr;
+  resource_user->outstanding_allocations = 0;
   for (int i = 0; i < GRPC_RULIST_COUNT; i++) {
-    resource_user->links[i].next = resource_user->links[i].prev = NULL;
+    resource_user->links[i].next = resource_user->links[i].prev = nullptr;
   }
-  if (name != NULL) {
+  if (name != nullptr) {
     resource_user->name = gpr_strdup(name);
   } else {
     gpr_asprintf(&resource_user->name, "anonymous_resource_user_%" PRIxPTR,
@@ -729,18 +763,18 @@ grpc_resource_user *grpc_resource_user_create(
   return resource_user;
 }
 
-grpc_resource_quota *grpc_resource_user_quota(
-    grpc_resource_user *resource_user) {
+grpc_resource_quota* grpc_resource_user_quota(
+    grpc_resource_user* resource_user) {
   return resource_user->resource_quota;
 }
 
-static void ru_ref_by(grpc_resource_user *resource_user, gpr_atm amount) {
+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);
 }
 
-static void ru_unref_by(grpc_exec_ctx *exec_ctx,
-                        grpc_resource_user *resource_user, gpr_atm amount) {
+static void ru_unref_by(grpc_exec_ctx* exec_ctx,
+                        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);
@@ -750,17 +784,17 @@ static void ru_unref_by(grpc_exec_ctx *exec_ctx,
   }
 }
 
-void grpc_resource_user_ref(grpc_resource_user *resource_user) {
+void grpc_resource_user_ref(grpc_resource_user* resource_user) {
   ru_ref_by(resource_user, 1);
 }
 
-void grpc_resource_user_unref(grpc_exec_ctx *exec_ctx,
-                              grpc_resource_user *resource_user) {
+void grpc_resource_user_unref(grpc_exec_ctx* exec_ctx,
+                              grpc_resource_user* resource_user) {
   ru_unref_by(exec_ctx, resource_user, 1);
 }
 
-void grpc_resource_user_shutdown(grpc_exec_ctx *exec_ctx,
-                                 grpc_resource_user *resource_user) {
+void grpc_resource_user_shutdown(grpc_exec_ctx* exec_ctx,
+                                 grpc_resource_user* resource_user) {
   if (gpr_atm_full_fetch_add(&resource_user->shutdown, 1) == 0) {
     GRPC_CLOSURE_SCHED(
         exec_ctx,
@@ -771,13 +805,14 @@ void grpc_resource_user_shutdown(grpc_exec_ctx *exec_ctx,
   }
 }
 
-void grpc_resource_user_alloc(grpc_exec_ctx *exec_ctx,
-                              grpc_resource_user *resource_user, size_t size,
-                              grpc_closure *optional_on_done) {
+void grpc_resource_user_alloc(grpc_exec_ctx* exec_ctx,
+                              grpc_resource_user* resource_user, size_t size,
+                              grpc_closure* optional_on_done) {
   gpr_mu_lock(&resource_user->mu);
   ru_ref_by(resource_user, (gpr_atm)size);
   resource_user->free_pool -= (int64_t)size;
-  if (GRPC_TRACER_ON(grpc_resource_quota_trace)) {
+  resource_user->outstanding_allocations += (int64_t)size;
+  if (grpc_resource_quota_trace.enabled()) {
     gpr_log(GPR_DEBUG, "RQ %s %s: alloc %" PRIdPTR "; free_pool -> %" PRId64,
             resource_user->resource_quota->name, resource_user->name, size,
             resource_user->free_pool);
@@ -791,17 +826,18 @@ void grpc_resource_user_alloc(grpc_exec_ctx *exec_ctx,
                          GRPC_ERROR_NONE);
     }
   } else {
+    resource_user->outstanding_allocations -= (int64_t)size;
     GRPC_CLOSURE_SCHED(exec_ctx, optional_on_done, GRPC_ERROR_NONE);
   }
   gpr_mu_unlock(&resource_user->mu);
 }
 
-void grpc_resource_user_free(grpc_exec_ctx *exec_ctx,
-                             grpc_resource_user *resource_user, size_t size) {
+void grpc_resource_user_free(grpc_exec_ctx* exec_ctx,
+                             grpc_resource_user* resource_user, size_t size) {
   gpr_mu_lock(&resource_user->mu);
   bool was_zero_or_negative = resource_user->free_pool <= 0;
   resource_user->free_pool += (int64_t)size;
-  if (GRPC_TRACER_ON(grpc_resource_quota_trace)) {
+  if (grpc_resource_quota_trace.enabled()) {
     gpr_log(GPR_DEBUG, "RQ %s %s: free %" PRIdPTR "; free_pool -> %" PRId64,
             resource_user->resource_quota->name, resource_user->name, size,
             resource_user->free_pool);
@@ -817,20 +853,20 @@ void grpc_resource_user_free(grpc_exec_ctx *exec_ctx,
   ru_unref_by(exec_ctx, resource_user, (gpr_atm)size);
 }
 
-void grpc_resource_user_post_reclaimer(grpc_exec_ctx *exec_ctx,
-                                       grpc_resource_user *resource_user,
+void grpc_resource_user_post_reclaimer(grpc_exec_ctx* exec_ctx,
+                                       grpc_resource_user* resource_user,
                                        bool destructive,
-                                       grpc_closure *closure) {
-  GPR_ASSERT(resource_user->new_reclaimers[destructive] == NULL);
+                                       grpc_closure* closure) {
+  GPR_ASSERT(resource_user->new_reclaimers[destructive] == nullptr);
   resource_user->new_reclaimers[destructive] = closure;
   GRPC_CLOSURE_SCHED(exec_ctx,
                      &resource_user->post_reclaimer_closure[destructive],
                      GRPC_ERROR_NONE);
 }
 
-void grpc_resource_user_finish_reclamation(grpc_exec_ctx *exec_ctx,
-                                           grpc_resource_user *resource_user) {
-  if (GRPC_TRACER_ON(grpc_resource_quota_trace)) {
+void grpc_resource_user_finish_reclamation(grpc_exec_ctx* exec_ctx,
+                                           grpc_resource_user* resource_user) {
+  if (grpc_resource_quota_trace.enabled()) {
     gpr_log(GPR_DEBUG, "RQ %s %s: reclamation complete",
             resource_user->resource_quota->name, resource_user->name);
   }
@@ -840,8 +876,8 @@ void grpc_resource_user_finish_reclamation(grpc_exec_ctx *exec_ctx,
 }
 
 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_resource_user_slice_allocator* slice_allocator,
+    grpc_resource_user* resource_user, grpc_iomgr_cb_func cb, void* p) {
   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,
@@ -850,19 +886,12 @@ void grpc_resource_user_slice_allocator_init(
 }
 
 void grpc_resource_user_alloc_slices(
-    grpc_exec_ctx *exec_ctx,
-    grpc_resource_user_slice_allocator *slice_allocator, size_t length,
-    size_t count, grpc_slice_buffer *dest) {
+    grpc_exec_ctx* exec_ctx,
+    grpc_resource_user_slice_allocator* slice_allocator, size_t length,
+    size_t count, grpc_slice_buffer* dest) {
   slice_allocator->length = length;
   slice_allocator->count = count;
   slice_allocator->dest = dest;
   grpc_resource_user_alloc(exec_ctx, slice_allocator->resource_user,
                            count * length, &slice_allocator->on_allocated);
 }
-
-grpc_slice grpc_resource_user_slice_malloc(grpc_exec_ctx *exec_ctx,
-                                           grpc_resource_user *resource_user,
-                                           size_t size) {
-  grpc_resource_user_alloc(exec_ctx, resource_user, size, NULL);
-  return ru_slice_create(resource_user, size);
-}