grpc 1.40.0.pre1 → 1.42.0.pre1

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

@@ -23,13 +23,13 @@
 
 #ifdef GRPC_CFSTREAM
 #import <CoreFoundation/CoreFoundation.h>
-#import "src/core/lib/iomgr/cfstream_handle.h"
 
 #include <grpc/grpc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/debug/trace.h"
+#import "src/core/lib/iomgr/cfstream_handle.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
 #include "src/core/lib/iomgr/ev_apple.h"

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

@@ -27,11 +27,9 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/iomgr/iomgr_internal.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_combiner_trace(false, "combiner");
 
@@ -128,17 +126,14 @@ static void push_first_on_exec_ctx(grpc_core::Combiner* lock) {
 
 static void combiner_exec(grpc_core::Combiner* lock, grpc_closure* cl,
                           grpc_error_handle error) {
-  GPR_TIMER_SCOPE("combiner.execute", 0);
-  GRPC_STATS_INC_COMBINER_LOCKS_SCHEDULED_ITEMS();
   gpr_atm last = gpr_atm_full_fetch_add(&lock->state, STATE_ELEM_COUNT_LOW_BIT);
   GRPC_COMBINER_TRACE(gpr_log(GPR_INFO,
                               "C:%p grpc_combiner_execute c=%p last=%" PRIdPTR,
                               lock, cl, last));
   if (last == 1) {
-    GRPC_STATS_INC_COMBINER_LOCKS_INITIATED();
-    GPR_TIMER_MARK("combiner.initiated", 0);
-    gpr_atm_no_barrier_store(&lock->initiating_exec_ctx_or_null,
-                             (gpr_atm)grpc_core::ExecCtx::Get());
+    gpr_atm_no_barrier_store(
+        &lock->initiating_exec_ctx_or_null,
+        reinterpret_cast<gpr_atm>(grpc_core::ExecCtx::Get()));
     // first element on this list: add it to the list of combiner locks
     // executing within this exec_ctx
     push_last_on_exec_ctx(lock);
@@ -174,14 +169,12 @@ static void offload(void* arg, grpc_error_handle /*error*/) {
 }
 
 static void queue_offload(grpc_core::Combiner* lock) {
-  GRPC_STATS_INC_COMBINER_LOCKS_OFFLOADED();
   move_next();
   GRPC_COMBINER_TRACE(gpr_log(GPR_INFO, "C:%p queue_offload", lock));
   grpc_core::Executor::Run(&lock->offload, GRPC_ERROR_NONE);
 }
 
 bool grpc_combiner_continue_exec_ctx() {
-  GPR_TIMER_SCOPE("combiner.continue_exec_ctx", 0);
   grpc_core::Combiner* lock =
       grpc_core::ExecCtx::Get()->combiner_data()->active_combiner;
   if (lock == nullptr) {
@@ -206,9 +199,8 @@ bool grpc_combiner_continue_exec_ctx() {
   // 3. the current thread is not a worker for any background poller
   // 4. the DEFAULT executor is threaded
   if (contended && grpc_core::ExecCtx::Get()->IsReadyToFinish() &&
-      !grpc_iomgr_is_any_background_poller_thread() &&
+      !grpc_iomgr_platform_is_any_background_poller_thread() &&
       grpc_core::Executor::IsThreadedDefault()) {
-    GPR_TIMER_MARK("offload_from_finished_exec_ctx", 0);
     // this execution context wants to move on: schedule remaining work to be
     // picked up on the executor
     queue_offload(lock);
@@ -225,11 +217,9 @@ bool grpc_combiner_continue_exec_ctx() {
     if (n == nullptr) {
       // queue is in an inconsistent state: use this as a cue that we should
       // go off and do something else for a while (and come back later)
-      GPR_TIMER_MARK("delay_busy", 0);
       queue_offload(lock);
       return true;
     }
-    GPR_TIMER_SCOPE("combiner.exec1", 0);
     grpc_closure* cl = reinterpret_cast<grpc_closure*>(n);
     grpc_error_handle cl_err = cl->error_data.error;
 #ifndef NDEBUG
@@ -243,7 +233,6 @@ bool grpc_combiner_continue_exec_ctx() {
     grpc_closure_list_init(&lock->final_list);
     int loops = 0;
     while (c != nullptr) {
-      GPR_TIMER_SCOPE("combiner.exec_1final", 0);
       GRPC_COMBINER_TRACE(
           gpr_log(GPR_INFO, "C:%p execute_final[%d] c=%p", lock, loops, c));
       grpc_closure* next = c->next_data.next;
@@ -257,7 +246,6 @@ bool grpc_combiner_continue_exec_ctx() {
     }
   }
 
-  GPR_TIMER_MARK("unref", 0);
   move_next();
   lock->time_to_execute_final_list = false;
   gpr_atm old_state =
@@ -304,13 +292,10 @@ static void combiner_finally_exec(grpc_core::Combiner* lock,
                                   grpc_closure* closure,
                                   grpc_error_handle error) {
   GPR_ASSERT(lock != nullptr);
-  GPR_TIMER_SCOPE("combiner.execute_finally", 0);
-  GRPC_STATS_INC_COMBINER_LOCKS_SCHEDULED_FINAL_ITEMS();
   GRPC_COMBINER_TRACE(gpr_log(
       GPR_INFO, "C:%p grpc_combiner_execute_finally c=%p; ac=%p", lock, closure,
       grpc_core::ExecCtx::Get()->combiner_data()->active_combiner));
   if (grpc_core::ExecCtx::Get()->combiner_data()->active_combiner != lock) {
-    GPR_TIMER_MARK("slowpath", 0);
     // Using error_data.scratch to store the combiner so that it can be accessed
     // in enqueue_finally.
     closure->error_data.scratch = reinterpret_cast<uintptr_t>(lock);
@@ -326,9 +311,10 @@ static void combiner_finally_exec(grpc_core::Combiner* lock,
 
 static void enqueue_finally(void* closure, grpc_error_handle error) {
   grpc_closure* cl = static_cast<grpc_closure*>(closure);
-  combiner_finally_exec(
-      reinterpret_cast<grpc_core::Combiner*>(cl->error_data.scratch), cl,
-      GRPC_ERROR_REF(error));
+  grpc_core::Combiner* lock =
+      reinterpret_cast<grpc_core::Combiner*>(cl->error_data.scratch);
+  cl->error_data.scratch = 0;
+  combiner_finally_exec(lock, cl, GRPC_ERROR_REF(error));
 }
 
 namespace grpc_core {

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

@@ -24,6 +24,7 @@
 #include <stddef.h>
 
 #include <grpc/support/atm.h>
+
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 

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

@@ -23,6 +23,7 @@
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
 
 #include <netinet/in.h>
+
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 
 #ifndef GRPC_SET_SOCKET_DUALSTACK_CUSTOM

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

@@ -62,10 +62,6 @@ absl::string_view grpc_endpoint_get_local_address(grpc_endpoint* ep) {
 
 int grpc_endpoint_get_fd(grpc_endpoint* ep) { return ep->vtable->get_fd(ep); }
 
-grpc_resource_user* grpc_endpoint_get_resource_user(grpc_endpoint* ep) {
-  return ep->vtable->get_resource_user(ep);
-}
-
 bool grpc_endpoint_can_track_err(grpc_endpoint* ep) {
   return ep->vtable->can_track_err(ep);
 }

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

@@ -26,6 +26,7 @@
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/time.h>
+
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resource_quota.h"
@@ -46,7 +47,6 @@ struct grpc_endpoint_vtable {
   void (*delete_from_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
   void (*shutdown)(grpc_endpoint* ep, grpc_error_handle why);
   void (*destroy)(grpc_endpoint* ep);
-  grpc_resource_user* (*get_resource_user)(grpc_endpoint* ep);
   absl::string_view (*get_peer)(grpc_endpoint* ep);
   absl::string_view (*get_local_address)(grpc_endpoint* ep);
   int (*get_fd)(grpc_endpoint* ep);
@@ -99,8 +99,6 @@ void grpc_endpoint_add_to_pollset_set(grpc_endpoint* ep,
 void grpc_endpoint_delete_from_pollset_set(grpc_endpoint* ep,
                                            grpc_pollset_set* pollset_set);
 
-grpc_resource_user* grpc_endpoint_get_resource_user(grpc_endpoint* ep);
-
 bool grpc_endpoint_can_track_err(grpc_endpoint* ep);
 
 struct grpc_endpoint {

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

@@ -23,7 +23,6 @@
 #ifdef GRPC_CFSTREAM_ENDPOINT
 
 #import <CoreFoundation/CoreFoundation.h>
-#import "src/core/lib/iomgr/endpoint_cfstream.h"
 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
@@ -34,6 +33,7 @@
 #include "src/core/lib/iomgr/cfstream_handle.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
+#import "src/core/lib/iomgr/endpoint_cfstream.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -59,11 +59,10 @@ struct CFStreamEndpoint {
 
   std::string peer_string;
   std::string local_address;
-  grpc_resource_user* resource_user;
-  grpc_resource_user_slice_allocator slice_allocator;
+  grpc_slice_allocator* slice_allocator;
 };
 static void CFStreamFree(CFStreamEndpoint* ep) {
-  grpc_resource_user_unref(ep->resource_user);
+  grpc_slice_allocator_destroy(ep->slice_allocator);
   CFRelease(ep->read_stream);
   CFRelease(ep->write_stream);
   CFSTREAM_HANDLE_UNREF(ep->stream_sync, "free");
@@ -111,8 +110,7 @@ static grpc_error_handle CFStreamAnnotateError(grpc_error_handle src_error,
   return grpc_error_set_str(
       grpc_error_set_int(src_error, GRPC_ERROR_INT_GRPC_STATUS,
                          GRPC_STATUS_UNAVAILABLE),
-      GRPC_ERROR_STR_TARGET_ADDRESS,
-      grpc_slice_from_copied_string(ep->peer_string.c_str()));
+      GRPC_ERROR_STR_TARGET_ADDRESS, ep->peer_string);
 }
 
 static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
@@ -151,7 +149,7 @@ static void CallWriteCb(CFStreamEndpoint* ep, grpc_error_handle error) {
 static void ReadAction(void* arg, grpc_error_handle error) {
   CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
   GPR_ASSERT(ep->read_cb != nullptr);
-  if (error) {
+  if (error != GRPC_ERROR_NONE) {
     grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
     CallReadCb(ep, GRPC_ERROR_REF(error));
     EP_UNREF(ep, "read");
@@ -193,7 +191,7 @@ static void ReadAction(void* arg, grpc_error_handle error) {
 static void WriteAction(void* arg, grpc_error_handle error) {
   CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
   GPR_ASSERT(ep->write_cb != nullptr);
-  if (error) {
+  if (error != GRPC_ERROR_NONE) {
     grpc_slice_buffer_reset_and_unref_internal(ep->write_slices);
     CallWriteCb(ep, GRPC_ERROR_REF(error));
     EP_UNREF(ep, "write");
@@ -263,9 +261,10 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
   ep_impl->read_slices = slices;
   grpc_slice_buffer_reset_and_unref_internal(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)) {
+  if (grpc_slice_allocator_allocate(
+          ep_impl->slice_allocator, GRPC_TCP_DEFAULT_READ_SLICE_SIZE, 1,
+          grpc_slice_allocator_intent::kReadBuffer, ep_impl->read_slices,
+          CFStreamReadAllocationDone, ep_impl)) {
     ep_impl->stream_sync->NotifyOnRead(&ep_impl->read_action);
   }
 }
@@ -287,14 +286,15 @@ static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
 void CFStreamShutdown(grpc_endpoint* ep, grpc_error_handle why) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown (%p)", ep_impl, why);
+    gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown (%s)", ep_impl,
+            grpc_error_std_string(why).c_str());
   }
   CFReadStreamClose(ep_impl->read_stream);
   CFWriteStreamClose(ep_impl->write_stream);
   ep_impl->stream_sync->Shutdown(why);
-  grpc_resource_user_shutdown(ep_impl->resource_user);
   if (grpc_tcp_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown DONE (%p)", ep_impl, why);
+    gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown DONE (%s)", ep_impl,
+            grpc_error_std_string(why).c_str());
   }
 }
 
@@ -306,11 +306,6 @@ void CFStreamDestroy(grpc_endpoint* ep) {
   EP_UNREF(ep_impl, "destroy");
 }
 
-grpc_resource_user* CFStreamGetResourceUser(grpc_endpoint* ep) {
-  CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
-  return ep_impl->resource_user;
-}
-
 absl::string_view CFStreamGetPeer(grpc_endpoint* ep) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   return ep_impl->peer_string;
@@ -337,7 +332,6 @@ static const grpc_endpoint_vtable vtable = {CFStreamRead,
                                             CFStreamDeleteFromPollsetSet,
                                             CFStreamShutdown,
                                             CFStreamDestroy,
-                                            CFStreamGetResourceUser,
                                             CFStreamGetPeer,
                                             CFStreamGetLocalAddress,
                                             CFStreamGetFD,
@@ -345,7 +339,7 @@ static const grpc_endpoint_vtable vtable = {CFStreamRead,
 
 grpc_endpoint* grpc_cfstream_endpoint_create(
     CFReadStreamRef read_stream, CFWriteStreamRef write_stream,
-    const char* peer_string, grpc_resource_quota* resource_quota,
+    const char* peer_string, grpc_slice_allocator* slice_allocator,
     CFStreamHandle* stream_sync) {
   CFStreamEndpoint* ep_impl = new CFStreamEndpoint;
   if (grpc_tcp_trace.enabled()) {
@@ -387,11 +381,7 @@ grpc_endpoint* grpc_cfstream_endpoint_create(
                     static_cast<void*>(ep_impl), grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&ep_impl->write_action, WriteAction,
                     static_cast<void*>(ep_impl), grpc_schedule_on_exec_ctx);
-  ep_impl->resource_user =
-      grpc_resource_user_create(resource_quota, peer_string);
-  grpc_resource_user_slice_allocator_init(&ep_impl->slice_allocator,
-                                          ep_impl->resource_user,
-                                          CFStreamReadAllocationDone, ep_impl);
+  ep_impl->slice_allocator = slice_allocator;
 
   return &ep_impl->base;
 }

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

@@ -41,7 +41,7 @@
 
 grpc_endpoint* grpc_cfstream_endpoint_create(
     CFReadStreamRef read_stream, CFWriteStreamRef write_stream,
-    const char* peer_string, grpc_resource_quota* resource_quota,
+    const char* peer_string, grpc_slice_allocator* slice_allocator,
     CFStreamHandle* stream_sync);
 
 #endif /* GRPC_CFSTREAM */

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

@@ -27,6 +27,7 @@ struct grpc_endpoint_pair {
   grpc_endpoint* client;
   grpc_endpoint* server;
 };
+
 grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
                                                    grpc_channel_args* args);
 

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

@@ -14,13 +14,12 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GRPC_USE_EVENT_ENGINE
-#include "src/core/lib/iomgr/port.h"
-
 #include <stdlib.h>
 
 #include <grpc/support/log.h>
 
 #include "src/core/lib/iomgr/endpoint_pair.h"
+#include "src/core/lib/iomgr/port.h"
 
 grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
     const char* /* name */, grpc_channel_args* /* args */) {

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

@@ -22,10 +22,6 @@
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 
-#include "src/core/lib/iomgr/endpoint_pair.h"
-#include "src/core/lib/iomgr/socket_utils_posix.h"
-#include "src/core/lib/iomgr/unix_sockets_posix.h"
-
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
@@ -38,8 +34,12 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/iomgr/endpoint_pair.h"
+#include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
+#include "src/core/lib/iomgr/unix_sockets_posix.h"
 
 static void create_sockets(int sv[2]) {
   int flags;
@@ -57,16 +57,20 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
   int sv[2];
   grpc_endpoint_pair p;
   create_sockets(sv);
-
   grpc_core::ExecCtx exec_ctx;
-
   std::string final_name = absl::StrCat(name, ":client");
-  p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
-                             args, "socketpair-server");
+  grpc_resource_quota* resource_quota =
+      grpc_resource_quota_from_channel_args(args, true);
+  p.client = grpc_tcp_create(
+      grpc_fd_create(sv[1], final_name.c_str(), false), args,
+      "socketpair-server",
+      grpc_slice_allocator_create(resource_quota, "server_endpoint", args));
   final_name = absl::StrCat(name, ":server");
-  p.server = grpc_tcp_create(grpc_fd_create(sv[0], final_name.c_str(), false),
-                             args, "socketpair-client");
-
+  p.server = grpc_tcp_create(
+      grpc_fd_create(sv[0], final_name.c_str(), false), args,
+      "socketpair-client",
+      grpc_slice_allocator_create(resource_quota, "client_endpoint", args));
+  grpc_resource_quota_unref_internal(resource_quota);
   return p;
 }
 

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

@@ -21,15 +21,15 @@
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_WINSOCK_SOCKET
-#include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/iomgr/endpoint_pair.h"
-#include "src/core/lib/iomgr/sockaddr.h"
-
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
 
 #include <grpc/support/log.h>
+
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/iomgr/endpoint_pair.h"
+#include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
 
@@ -76,11 +76,19 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
   grpc_endpoint_pair p;
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
-  p.client = grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
-                             channel_args, "endpoint:server");
-  p.server = grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
-                             channel_args, "endpoint:client");
-
+  grpc_resource_quota* resource_quota =
+      grpc_resource_quota_from_channel_args(channel_args, true);
+  p.client =
+      grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
+                      channel_args, "endpoint:server",
+                      grpc_slice_allocator_create(
+                          resource_quota, "endpoint:server", channel_args));
+  p.server =
+      grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
+                      channel_args, "endpoint:client",
+                      grpc_slice_allocator_create(
+                          resource_quota, "endpoint:client", channel_args));
+  grpc_resource_quota_unref_internal(resource_quota);
   return p;
 }