grpc 1.24.0 → 1.25.0

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

@@ -25,9 +25,36 @@
 
 #include <grpc/support/atm.h>
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/mpscq.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+namespace grpc_core {
+// TODO(yashkt) : Remove this class and replace it with a class that does not
+// use ExecCtx
+class Combiner {
+ public:
+  void Run(grpc_closure* closure, grpc_error* error);
+  // TODO(yashkt) : Remove this method
+  void FinallyRun(grpc_closure* closure, grpc_error* error);
+  Combiner* next_combiner_on_this_exec_ctx = nullptr;
+  grpc_closure_scheduler scheduler;
+  grpc_closure_scheduler finally_scheduler;
+  MultiProducerSingleConsumerQueue queue;
+  // either:
+  // a pointer to the initiating exec ctx if that is the only exec_ctx that has
+  // ever queued to this combiner, or NULL. If this is non-null, it's not
+  // dereferencable (since the initiating exec_ctx may have gone out of scope)
+  gpr_atm initiating_exec_ctx_or_null;
+  // state is:
+  // lower bit - zero if orphaned (STATE_UNORPHANED)
+  // other bits - number of items queued on the lock (STATE_ELEM_COUNT_LOW_BIT)
+  gpr_atm state;
+  bool time_to_execute_final_list = false;
+  grpc_closure_list final_list;
+  grpc_closure offload;
+  gpr_refcount refs;
+};
+}  // namespace grpc_core
+
 // Provides serialized access to some resource.
 // Each action queued on a combiner is executed serially in a borrowed thread.
 // The actual thread executing actions may change over time (but there will only
@@ -35,7 +62,7 @@
 
 // Initialize the lock, with an optional workqueue to shift load to when
 // necessary
-grpc_combiner* grpc_combiner_create(void);
+grpc_core::Combiner* grpc_combiner_create(void);
 
 #ifndef NDEBUG
 #define GRPC_COMBINER_DEBUG_ARGS \
@@ -52,12 +79,9 @@ grpc_combiner* grpc_combiner_create(void);
 
 // Ref/unref the lock, for when we're sharing the lock ownership
 // Prefer to use the macros above
-grpc_combiner* grpc_combiner_ref(grpc_combiner* lock GRPC_COMBINER_DEBUG_ARGS);
-void grpc_combiner_unref(grpc_combiner* lock GRPC_COMBINER_DEBUG_ARGS);
-// Fetch a scheduler to schedule closures against
-grpc_closure_scheduler* grpc_combiner_scheduler(grpc_combiner* lock);
-// Scheduler to execute \a action within the lock just prior to unlocking.
-grpc_closure_scheduler* grpc_combiner_finally_scheduler(grpc_combiner* lock);
+grpc_core::Combiner* grpc_combiner_ref(
+    grpc_core::Combiner* lock GRPC_COMBINER_DEBUG_ARGS);
+void grpc_combiner_unref(grpc_core::Combiner* lock GRPC_COMBINER_DEBUG_ARGS);
 
 bool grpc_combiner_continue_exec_ctx();
 

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

@@ -261,10 +261,12 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
   ep_impl->read_cb = cb;
   ep_impl->read_slices = slices;
   grpc_slice_buffer_reset_and_unref_internal(slices);
-  grpc_resource_user_alloc_slices(&ep_impl->slice_allocator,
-                                  GRPC_TCP_DEFAULT_READ_SLICE_SIZE, 1,
-                                  ep_impl->read_slices);
   EP_REF(ep_impl, "read");
+  if (grpc_resource_user_alloc_slices(&ep_impl->slice_allocator,
+                                      GRPC_TCP_DEFAULT_READ_SLICE_SIZE, 1,
+                                      ep_impl->read_slices)) {
+    ep_impl->stream_sync->NotifyOnRead(&ep_impl->read_action);
+  }
 }
 
 static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,

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

@@ -658,7 +658,7 @@ static int poll_deadline_to_millis_timeout(grpc_millis millis) {
    NOTE ON SYNCRHONIZATION: Similar to do_epoll_wait(), this function is only
    called by g_active_poller thread. So there is no need for synchronization
    when accessing fields in g_epoll_set */
-static grpc_error* process_epoll_events(grpc_pollset* pollset) {
+static grpc_error* process_epoll_events(grpc_pollset* /*pollset*/) {
   GPR_TIMER_SCOPE("process_epoll_events", 0);
 
   static const char* err_desc = "process_events";
@@ -1219,7 +1219,7 @@ done:
   return ret_err;
 }
 
-static void pollset_add_fd(grpc_pollset* pollset, grpc_fd* fd) {}
+static void pollset_add_fd(grpc_pollset* /*pollset*/, grpc_fd* /*fd*/) {}
 
 /*******************************************************************************
  * Pollset-set Definitions
@@ -1229,21 +1229,23 @@ static grpc_pollset_set* pollset_set_create(void) {
   return (grpc_pollset_set*)(static_cast<intptr_t>(0xdeafbeef));
 }
 
-static void pollset_set_destroy(grpc_pollset_set* pss) {}
+static void pollset_set_destroy(grpc_pollset_set* /*pss*/) {}
 
-static void pollset_set_add_fd(grpc_pollset_set* pss, grpc_fd* fd) {}
+static void pollset_set_add_fd(grpc_pollset_set* /*pss*/, grpc_fd* /*fd*/) {}
 
-static void pollset_set_del_fd(grpc_pollset_set* pss, grpc_fd* fd) {}
+static void pollset_set_del_fd(grpc_pollset_set* /*pss*/, grpc_fd* /*fd*/) {}
 
-static void pollset_set_add_pollset(grpc_pollset_set* pss, grpc_pollset* ps) {}
+static void pollset_set_add_pollset(grpc_pollset_set* /*pss*/,
+                                    grpc_pollset* /*ps*/) {}
 
-static void pollset_set_del_pollset(grpc_pollset_set* pss, grpc_pollset* ps) {}
+static void pollset_set_del_pollset(grpc_pollset_set* /*pss*/,
+                                    grpc_pollset* /*ps*/) {}
 
-static void pollset_set_add_pollset_set(grpc_pollset_set* bag,
-                                        grpc_pollset_set* item) {}
+static void pollset_set_add_pollset_set(grpc_pollset_set* /*bag*/,
+                                        grpc_pollset_set* /*item*/) {}
 
-static void pollset_set_del_pollset_set(grpc_pollset_set* bag,
-                                        grpc_pollset_set* item) {}
+static void pollset_set_del_pollset_set(grpc_pollset_set* /*bag*/,
+                                        grpc_pollset_set* /*item*/) {}
 
 /*******************************************************************************
  * Event engine binding
@@ -1253,8 +1255,8 @@ static bool is_any_background_poller_thread(void) { return false; }
 
 static void shutdown_background_closure(void) {}
 
-static bool add_closure_to_background_poller(grpc_closure* closure,
-                                             grpc_error* error) {
+static bool add_closure_to_background_poller(grpc_closure* /*closure*/,
+                                             grpc_error* /*error*/) {
   return false;
 }
 
@@ -1325,7 +1327,8 @@ static void reset_event_manager_on_fork() {
 /* It is possible that GLIBC has epoll but the underlying kernel doesn't.
  * Create epoll_fd (epoll_set_init() takes care of that) to make sure epoll
  * support is available */
-const grpc_event_engine_vtable* grpc_init_epoll1_linux(bool explicit_request) {
+const grpc_event_engine_vtable* grpc_init_epoll1_linux(
+    bool /*explicit_request*/) {
   if (!grpc_has_wakeup_fd()) {
     gpr_log(GPR_ERROR, "Skipping epoll1 because of no wakeup fd.");
     return nullptr;
@@ -1356,7 +1359,8 @@ const grpc_event_engine_vtable* grpc_init_epoll1_linux(bool explicit_request) {
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
 /* If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
  * NULL */
-const grpc_event_engine_vtable* grpc_init_epoll1_linux(bool explicit_request) {
+const grpc_event_engine_vtable* grpc_init_epoll1_linux(
+    bool /*explicit_request*/) {
   return nullptr;
 }
 #endif /* defined(GRPC_POSIX_SOCKET_EV_EPOLL1) */

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

@@ -1379,7 +1379,9 @@ static void reset_event_manager_on_fork() {
   gpr_mu_lock(&fork_fd_list_mu);
   while (fork_fd_list_head != nullptr) {
     if (fork_fd_list_head->fd != nullptr) {
-      close(fork_fd_list_head->fd->fd);
+      if (!fork_fd_list_head->fd->closed) {
+        close(fork_fd_list_head->fd->fd);
+      }
       fork_fd_list_head->fd->fd = -1;
     } else {
       close(fork_fd_list_head->cached_wakeup_fd->fd.read_fd);

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

@@ -63,6 +63,7 @@ grpc_millis grpc_cycle_counter_to_millis_round_down(gpr_cycle_counter cycles);
 grpc_millis grpc_cycle_counter_to_millis_round_up(gpr_cycle_counter cycles);
 
 namespace grpc_core {
+class Combiner;
 /** Execution context.
  *  A bag of data that collects information along a callstack.
  *  It is created on the stack at core entry points (public API or iomgr), and
@@ -136,9 +137,9 @@ class ExecCtx {
 
   struct CombinerData {
     /* currently active combiner: updated only via combiner.c */
-    grpc_combiner* active_combiner;
+    Combiner* active_combiner;
     /* last active combiner in the active combiner list */
-    grpc_combiner* last_combiner;
+    Combiner* last_combiner;
   };
 
   /** Only to be used by grpc-combiner code */
@@ -225,7 +226,7 @@ class ExecCtx {
   virtual bool CheckReadyToFinish() { return false; }
 
   /** Disallow delete on ExecCtx. */
-  static void operator delete(void* p) { abort(); }
+  static void operator delete(void* /* p */) { abort(); }
 
  private:
   /** Set exec_ctx_ to exec_ctx. */

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

@@ -164,7 +164,6 @@ void Executor::SetThreading(bool threading) {
 
     GPR_ASSERT(num_threads_ == 0);
     gpr_atm_rel_store(&num_threads_, 1);
-    gpr_tls_init(&g_this_thread_state);
     thd_state_ = static_cast<ThreadState*>(
         gpr_zalloc(sizeof(ThreadState) * max_threads_));
 
@@ -213,7 +212,6 @@ void Executor::SetThreading(bool threading) {
     }
 
     gpr_free(thd_state_);
-    gpr_tls_destroy(&g_this_thread_state);
 
     // grpc_iomgr_shutdown_background_closure() will close all the registered
     // fds in the background poller, and wait for all pending closures to
@@ -264,6 +262,8 @@ void Executor::ThreadMain(void* arg) {
     grpc_core::ExecCtx::Get()->InvalidateNow();
     subtract_depth = RunClosures(ts->name, closures);
   }
+
+  gpr_tls_set(&g_this_thread_state, reinterpret_cast<intptr_t>(nullptr));
 }
 
 void Executor::Enqueue(grpc_closure* closure, grpc_error* error,
@@ -485,4 +485,6 @@ void Executor::SetThreadingDefault(bool enable) {
   executors[static_cast<size_t>(ExecutorType::DEFAULT)]->SetThreading(enable);
 }
 
+void grpc_executor_global_init() { gpr_tls_init(&g_this_thread_state); }
+
 }  // namespace grpc_core

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

@@ -117,6 +117,9 @@ class Executor {
   gpr_spinlock adding_thread_lock_;
 };
 
+// Global initializer for executor
+void grpc_executor_global_init();
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_EXECUTOR_H */

data/src/core/lib/iomgr/executor/mpmcqueue.h

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/stats.h"
-#include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/sync.h"
 
@@ -38,17 +37,15 @@ class MPMCQueueInterface {
 
   // Puts elem into queue immediately at the end of queue.
   // This might cause to block on full queue depending on implementation.
-  virtual void Put(void* elem) GRPC_ABSTRACT;
+  virtual void Put(void* elem) = 0;
 
   // Removes the oldest element from the queue and return it.
   // This might cause to block on empty queue depending on implementation.
   // Optional argument for collecting stats purpose.
-  virtual void* Get(gpr_timespec* wait_time = nullptr) GRPC_ABSTRACT;
+  virtual void* Get(gpr_timespec* wait_time = nullptr) = 0;
 
   // Returns number of elements in the queue currently
-  virtual int count() const GRPC_ABSTRACT;
-
-  GRPC_ABSTRACT_BASE_CLASS
+  virtual int count() const = 0;
 };
 
 class InfLenFIFOQueue : public MPMCQueueInterface {

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

@@ -58,8 +58,7 @@ void ThreadPool::SharedThreadPoolConstructor() {
   threads_ = static_cast<ThreadPoolWorker**>(
       gpr_zalloc(num_threads_ * sizeof(ThreadPoolWorker*)));
   for (int i = 0; i < num_threads_; ++i) {
-    threads_[i] =
-        New<ThreadPoolWorker>(thd_name_, this, queue_, thread_options_, i);
+    threads_[i] = New<ThreadPoolWorker>(thd_name_, queue_, thread_options_, i);
     threads_[i]->Start();
   }
 }

data/src/core/lib/iomgr/executor/threadpool.h

@@ -43,31 +43,27 @@ class ThreadPoolInterface {
   // current thread to be blocked (in case of unable to schedule).
   // Closure should contain a function pointer and arguments it will take, more
   // details for closure struct at /grpc/include/grpc/impl/codegen/grpc_types.h
-  virtual void Add(grpc_experimental_completion_queue_functor* closure)
-      GRPC_ABSTRACT;
+  virtual void Add(grpc_experimental_completion_queue_functor* closure) = 0;
 
   // Returns the current number of pending closures
-  virtual int num_pending_closures() const GRPC_ABSTRACT;
+  virtual int num_pending_closures() const = 0;
 
   // Returns the capacity of pool (number of worker threads in pool)
-  virtual int pool_capacity() const GRPC_ABSTRACT;
+  virtual int pool_capacity() const = 0;
 
   // Thread option accessor
-  virtual const Thread::Options& thread_options() const GRPC_ABSTRACT;
+  virtual const Thread::Options& thread_options() const = 0;
 
   // Returns the thread name for threads in this ThreadPool.
-  virtual const char* thread_name() const GRPC_ABSTRACT;
-
-  GRPC_ABSTRACT_BASE_CLASS
+  virtual const char* thread_name() const = 0;
 };
 
 // Worker thread for threadpool. Executes closures in the queue, until getting a
 // NULL closure.
 class ThreadPoolWorker {
  public:
-  ThreadPoolWorker(const char* thd_name, ThreadPoolInterface* pool,
-                   MPMCQueueInterface* queue, Thread::Options& options,
-                   int index)
+  ThreadPoolWorker(const char* thd_name, MPMCQueueInterface* queue,
+                   Thread::Options& options, int index)
       : queue_(queue), thd_name_(thd_name), index_(index) {
     thd_ = Thread(thd_name,
                   [](void* th) { static_cast<ThreadPoolWorker*>(th)->Run(); },

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

@@ -132,7 +132,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_core::Combiner* combiner;
   /* Size of the resource quota */
   int64_t size;
   /* Amount of free memory in the resource quota */
@@ -293,7 +293,8 @@ static void rq_step_sched(grpc_resource_quota* resource_quota) {
   if (resource_quota->step_scheduled) return;
   resource_quota->step_scheduled = true;
   grpc_resource_quota_ref_internal(resource_quota);
-  GRPC_CLOSURE_SCHED(&resource_quota->rq_step_closure, GRPC_ERROR_NONE);
+  resource_quota->combiner->FinallyRun(&resource_quota->rq_step_closure,
+                                       GRPC_ERROR_NONE);
 }
 
 /* update the atomically available resource estimate - use no barriers since
@@ -583,16 +584,19 @@ static void ru_destroy(void* ru, grpc_error* error) {
   gpr_free(resource_user);
 }
 
+static void ru_alloc_slices(
+    grpc_resource_user_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,
+                                               slice_allocator->length));
+  }
+}
+
 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);
-  if (error == GRPC_ERROR_NONE) {
-    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,
-                                                 slice_allocator->length));
-    }
-  }
+  if (error == GRPC_ERROR_NONE) ru_alloc_slices(slice_allocator);
   GRPC_CLOSURE_RUN(&slice_allocator->on_done, GRPC_ERROR_REF(error));
 }
 
@@ -652,10 +656,9 @@ grpc_resource_quota* grpc_resource_quota_create(const char* name) {
                  (intptr_t)resource_quota);
   }
   GRPC_CLOSURE_INIT(&resource_quota->rq_step_closure, rq_step, resource_quota,
-                    grpc_combiner_finally_scheduler(resource_quota->combiner));
+                    nullptr);
   GRPC_CLOSURE_INIT(&resource_quota->rq_reclamation_done_closure,
-                    rq_reclamation_done, resource_quota,
-                    grpc_combiner_scheduler(resource_quota->combiner));
+                    rq_reclamation_done, resource_quota, nullptr);
   for (int i = 0; i < GRPC_RULIST_COUNT; i++) {
     resource_quota->roots[i] = nullptr;
   }
@@ -771,19 +774,15 @@ grpc_resource_user* grpc_resource_user_create(
   resource_user->resource_quota =
       grpc_resource_quota_ref_internal(resource_quota);
   GRPC_CLOSURE_INIT(&resource_user->allocate_closure, &ru_allocate,
-                    resource_user,
-                    grpc_combiner_scheduler(resource_quota->combiner));
+                    resource_user, nullptr);
   GRPC_CLOSURE_INIT(&resource_user->add_to_free_pool_closure,
-                    &ru_add_to_free_pool, resource_user,
-                    grpc_combiner_scheduler(resource_quota->combiner));
+                    &ru_add_to_free_pool, resource_user, nullptr);
   GRPC_CLOSURE_INIT(&resource_user->post_reclaimer_closure[0],
-                    &ru_post_benign_reclaimer, resource_user,
-                    grpc_combiner_scheduler(resource_quota->combiner));
+                    &ru_post_benign_reclaimer, resource_user, nullptr);
   GRPC_CLOSURE_INIT(&resource_user->post_reclaimer_closure[1],
-                    &ru_post_destructive_reclaimer, resource_user,
-                    grpc_combiner_scheduler(resource_quota->combiner));
+                    &ru_post_destructive_reclaimer, resource_user, nullptr);
   GRPC_CLOSURE_INIT(&resource_user->destroy_closure, &ru_destroy, resource_user,
-                    grpc_combiner_scheduler(resource_quota->combiner));
+                    nullptr);
   gpr_mu_init(&resource_user->mu);
   gpr_atm_rel_store(&resource_user->refs, 1);
   gpr_atm_rel_store(&resource_user->shutdown, 0);
@@ -824,7 +823,8 @@ static void ru_unref_by(grpc_resource_user* resource_user, gpr_atm amount) {
   gpr_atm old = gpr_atm_full_fetch_add(&resource_user->refs, -amount);
   GPR_ASSERT(old >= amount);
   if (old == amount) {
-    GRPC_CLOSURE_SCHED(&resource_user->destroy_closure, GRPC_ERROR_NONE);
+    resource_user->resource_quota->combiner->Run(
+        &resource_user->destroy_closure, GRPC_ERROR_NONE);
   }
 }
 
@@ -838,10 +838,8 @@ void grpc_resource_user_unref(grpc_resource_user* resource_user) {
 
 void grpc_resource_user_shutdown(grpc_resource_user* resource_user) {
   if (gpr_atm_full_fetch_add(&resource_user->shutdown, 1) == 0) {
-    GRPC_CLOSURE_SCHED(
-        GRPC_CLOSURE_CREATE(
-            ru_shutdown, resource_user,
-            grpc_combiner_scheduler(resource_user->resource_quota->combiner)),
+    resource_user->resource_quota->combiner->Run(
+        GRPC_CLOSURE_CREATE(ru_shutdown, resource_user, nullptr),
         GRPC_ERROR_NONE);
   }
 }
@@ -880,7 +878,7 @@ void grpc_resource_user_free_threads(grpc_resource_user* resource_user,
   gpr_mu_unlock(&resource_user->resource_quota->thread_count_mu);
 }
 
-static void resource_user_alloc_locked(grpc_resource_user* resource_user,
+static bool resource_user_alloc_locked(grpc_resource_user* resource_user,
                                        size_t size,
                                        grpc_closure* optional_on_done) {
   ru_ref_by(resource_user, static_cast<gpr_atm>(size));
@@ -890,19 +888,19 @@ static void resource_user_alloc_locked(grpc_resource_user* resource_user,
             resource_user->resource_quota->name, resource_user->name, size,
             resource_user->free_pool);
   }
-  if (resource_user->free_pool < 0) {
-    if (optional_on_done != nullptr) {
-      resource_user->outstanding_allocations += static_cast<int64_t>(size);
-      grpc_closure_list_append(&resource_user->on_allocated, optional_on_done,
-                               GRPC_ERROR_NONE);
-    }
-    if (!resource_user->allocating) {
-      resource_user->allocating = true;
-      GRPC_CLOSURE_SCHED(&resource_user->allocate_closure, GRPC_ERROR_NONE);
-    }
-  } else {
-    GRPC_CLOSURE_SCHED(optional_on_done, GRPC_ERROR_NONE);
+  if (GPR_LIKELY(resource_user->free_pool >= 0)) return true;
+  // Slow path: We need to wait for the free pool to refill.
+  if (optional_on_done != nullptr) {
+    resource_user->outstanding_allocations += static_cast<int64_t>(size);
+    grpc_closure_list_append(&resource_user->on_allocated, optional_on_done,
+                             GRPC_ERROR_NONE);
   }
+  if (!resource_user->allocating) {
+    resource_user->allocating = true;
+    resource_user->resource_quota->combiner->Run(
+        &resource_user->allocate_closure, GRPC_ERROR_NONE);
+  }
+  return false;
 }
 
 bool grpc_resource_user_safe_alloc(grpc_resource_user* resource_user,
@@ -926,15 +924,17 @@ bool grpc_resource_user_safe_alloc(grpc_resource_user* resource_user,
   return true;
 }
 
-void grpc_resource_user_alloc(grpc_resource_user* resource_user, size_t size,
+bool grpc_resource_user_alloc(grpc_resource_user* resource_user, size_t size,
                               grpc_closure* optional_on_done) {
   // TODO(juanlishen): Maybe return immediately if shutting down. Deferring this
   // because some tests become flaky after the change.
   gpr_mu_lock(&resource_user->mu);
   grpc_resource_quota* resource_quota = resource_user->resource_quota;
   gpr_atm_no_barrier_fetch_add(&resource_quota->used, size);
-  resource_user_alloc_locked(resource_user, size, optional_on_done);
+  const bool ret =
+      resource_user_alloc_locked(resource_user, size, optional_on_done);
   gpr_mu_unlock(&resource_user->mu);
+  return ret;
 }
 
 void grpc_resource_user_free(grpc_resource_user* resource_user, size_t size) {
@@ -953,8 +953,8 @@ void grpc_resource_user_free(grpc_resource_user* resource_user, size_t size) {
   if (is_bigger_than_zero && was_zero_or_negative &&
       !resource_user->added_to_free_pool) {
     resource_user->added_to_free_pool = true;
-    GRPC_CLOSURE_SCHED(&resource_user->add_to_free_pool_closure,
-                       GRPC_ERROR_NONE);
+    resource_quota->combiner->Run(&resource_user->add_to_free_pool_closure,
+                                  GRPC_ERROR_NONE);
   }
   gpr_mu_unlock(&resource_user->mu);
   ru_unref_by(resource_user, static_cast<gpr_atm>(size));
@@ -965,8 +965,8 @@ void grpc_resource_user_post_reclaimer(grpc_resource_user* resource_user,
                                        grpc_closure* closure) {
   GPR_ASSERT(resource_user->new_reclaimers[destructive] == nullptr);
   resource_user->new_reclaimers[destructive] = closure;
-  GRPC_CLOSURE_SCHED(&resource_user->post_reclaimer_closure[destructive],
-                     GRPC_ERROR_NONE);
+  resource_user->resource_quota->combiner->Run(
+      &resource_user->post_reclaimer_closure[destructive], GRPC_ERROR_NONE);
 }
 
 void grpc_resource_user_finish_reclamation(grpc_resource_user* resource_user) {
@@ -974,7 +974,7 @@ void grpc_resource_user_finish_reclamation(grpc_resource_user* resource_user) {
     gpr_log(GPR_INFO, "RQ %s %s: reclamation complete",
             resource_user->resource_quota->name, resource_user->name);
   }
-  GRPC_CLOSURE_SCHED(
+  resource_user->resource_quota->combiner->Run(
       &resource_user->resource_quota->rq_reclamation_done_closure,
       GRPC_ERROR_NONE);
 }
@@ -989,18 +989,22 @@ void grpc_resource_user_slice_allocator_init(
   slice_allocator->resource_user = resource_user;
 }
 
-void grpc_resource_user_alloc_slices(
+bool grpc_resource_user_alloc_slices(
     grpc_resource_user_slice_allocator* slice_allocator, size_t length,
     size_t count, grpc_slice_buffer* dest) {
-  if (gpr_atm_no_barrier_load(&slice_allocator->resource_user->shutdown)) {
+  if (GPR_UNLIKELY(
+          gpr_atm_no_barrier_load(&slice_allocator->resource_user->shutdown))) {
     GRPC_CLOSURE_SCHED(
         &slice_allocator->on_allocated,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resource user shutdown"));
-    return;
+    return false;
   }
   slice_allocator->length = length;
   slice_allocator->count = count;
   slice_allocator->dest = dest;
-  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 * length,
+                               &slice_allocator->on_allocated);
+  if (ret) ru_alloc_slices(slice_allocator);
+  return ret;
 }