grpc 1.28.0.pre2 → 1.31.0.pre1

data/src/core/lib/channel/channel_args.cc

@@ -21,6 +21,11 @@
 #include <limits.h>
 #include <string.h>
 
+#include <vector>
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/impl/codegen/log.h>
@@ -336,32 +341,28 @@ grpc_arg grpc_channel_arg_pointer_create(
   return arg;
 }
 
-char* grpc_channel_args_string(const grpc_channel_args* args) {
-  if (args == nullptr) return nullptr;
-  gpr_strvec v;
-  gpr_strvec_init(&v);
+std::string grpc_channel_args_string(const grpc_channel_args* args) {
+  if (args == nullptr) return "";
+  std::vector<std::string> arg_strings;
   for (size_t i = 0; i < args->num_args; ++i) {
     const grpc_arg& arg = args->args[i];
-    char* s;
+    std::string arg_string;
     switch (arg.type) {
       case GRPC_ARG_INTEGER:
-        gpr_asprintf(&s, "%s=%d", arg.key, arg.value.integer);
+        arg_string = absl::StrFormat("%s=%d", arg.key, arg.value.integer);
         break;
       case GRPC_ARG_STRING:
-        gpr_asprintf(&s, "%s=%s", arg.key, arg.value.string);
+        arg_string = absl::StrFormat("%s=%s", arg.key, arg.value.string);
         break;
       case GRPC_ARG_POINTER:
-        gpr_asprintf(&s, "%s=%p", arg.key, arg.value.pointer.p);
+        arg_string = absl::StrFormat("%s=%p", arg.key, arg.value.pointer.p);
         break;
       default:
-        gpr_asprintf(&s, "arg with unknown type");
+        arg_string = "arg with unknown type";
     }
-    gpr_strvec_add(&v, s);
+    arg_strings.push_back(arg_string);
   }
-  char* result =
-      gpr_strjoin_sep(const_cast<const char**>(v.strs), v.count, ", ", nullptr);
-  gpr_strvec_destroy(&v);
-  return result;
+  return absl::StrJoin(arg_strings, ", ");
 }
 
 namespace {

data/src/core/lib/channel/channel_args.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include <grpc/grpc.h>
 
 #include "src/core/lib/surface/channel_stack_type.h"
@@ -116,7 +118,7 @@ grpc_arg grpc_channel_arg_pointer_create(char* name, void* value,
 
 // Returns a string representing channel args in human-readable form.
 // Callers takes ownership of result.
-char* grpc_channel_args_string(const grpc_channel_args* args);
+std::string grpc_channel_args_string(const grpc_channel_args* args);
 
 // Takes ownership of the old_args
 typedef grpc_channel_args* (*grpc_channel_args_client_channel_creation_mutator)(

data/src/core/lib/channel/channel_stack.h

@@ -31,7 +31,18 @@
    chains are linear, then channel stacks provide a mechanism to minimize
    allocations for that chain.
    Call stacks are created by channel stacks and represent the per-call data
-   for that stack. */
+   for that stack.
+
+   Implementations should take care of the following details for a batch -
+   1. Synchronization is achieved with a CallCombiner. View
+   src/core/lib/iomgr/call_combiner.h for more details.
+   2. If the filter wants to inject an error on the way down, it needs to call
+   grpc_transport_stream_op_batch_finish_with_failure from within the call
+   combiner. This will cause any batch callbacks to be called with that error.
+   3. If the filter wants to inject an error on the way up (from a callback), it
+   should also inject that error in the recv_trailing_metadata callback so that
+   it can have an effect on the call status.
+*/
 
 #include <grpc/support/port_platform.h>
 
@@ -54,16 +65,15 @@ typedef struct grpc_call_element grpc_call_element;
 typedef struct grpc_channel_stack grpc_channel_stack;
 typedef struct grpc_call_stack grpc_call_stack;
 
-typedef struct {
+struct grpc_channel_element_args {
   grpc_channel_stack* channel_stack;
   const grpc_channel_args* channel_args;
   /** Transport, iff it is known */
   grpc_transport* optional_transport;
   int is_first;
   int is_last;
-} grpc_channel_element_args;
-
-typedef struct {
+};
+struct grpc_call_element_args {
   grpc_call_stack* call_stack;
   const void* server_transport_data;
   grpc_call_context_element* context;
@@ -72,13 +82,11 @@ typedef struct {
   grpc_millis deadline;
   grpc_core::Arena* arena;
   grpc_core::CallCombiner* call_combiner;
-} grpc_call_element_args;
-
-typedef struct {
+};
+struct grpc_call_stats {
   grpc_transport_stream_stats transport_stream_stats;
   gpr_timespec latency; /* From call creating to enqueing of received status */
-} grpc_call_stats;
-
+};
 /** Information about the call upon completion. */
 struct grpc_call_final_info {
   grpc_call_stats stats;
@@ -96,7 +104,7 @@ struct grpc_call_final_info {
    4. a name, which is useful when debugging
 
    Members are laid out in approximate frequency of use order. */
-typedef struct {
+struct grpc_channel_filter {
   /* Called to eg. send/receive data on a call.
      See grpc_call_next_op on how to call the next element in the stack */
   void (*start_transport_stream_op_batch)(grpc_call_element* elem,
@@ -152,8 +160,7 @@ typedef struct {
 
   /* The name of this filter */
   const char* name;
-} grpc_channel_filter;
-
+};
 /* A channel_element tracks its filter and the filter requested memory within
    a channel allocation */
 struct grpc_channel_element {

data/src/core/lib/channel/channel_trace.cc

@@ -146,14 +146,12 @@ const char* severity_string(ChannelTrace::Severity severity) {
 
 Json ChannelTrace::TraceEvent::RenderTraceEvent() const {
   char* description = grpc_slice_to_c_string(data_);
-  char* ts_str = gpr_format_timespec(timestamp_);
   Json::Object object = {
       {"description", description},
       {"severity", severity_string(severity_)},
-      {"timestamp", ts_str},
+      {"timestamp", gpr_format_timespec(timestamp_)},
   };
   gpr_free(description);
-  gpr_free(ts_str);
   if (referenced_entity_ != nullptr) {
     const bool is_channel =
         (referenced_entity_->type() == BaseNode::EntityType::kTopLevelChannel ||
@@ -171,11 +169,9 @@ Json ChannelTrace::RenderJson() const {
   if (max_event_memory_ == 0) {
     return Json();  // JSON null
   }
-  char* ts_str = gpr_format_timespec(time_created_);
   Json::Object object = {
-      {"creationTimestamp", ts_str},
+      {"creationTimestamp", gpr_format_timespec(time_created_)},
   };
-  gpr_free(ts_str);
   if (num_events_logged_ > 0) {
     object["numEventsLogged"] = std::to_string(num_events_logged_);
   }

data/src/core/lib/channel/channelz.cc

@@ -156,9 +156,7 @@ void CallCountingHelper::PopulateCallCounts(Json::Object* object) {
     gpr_timespec ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(data.last_call_started_cycle),
         GPR_CLOCK_REALTIME);
-    char* ts_str = gpr_format_timespec(ts);
-    (*object)["lastCallStartedTimestamp"] = ts_str;
-    gpr_free(ts_str);
+    (*object)["lastCallStartedTimestamp"] = gpr_format_timespec(ts);
   }
   if (data.calls_succeeded != 0) {
     (*object)["callsSucceeded"] = std::to_string(data.calls_succeeded);
@@ -387,15 +385,14 @@ void PopulateSocketAddressJson(Json::Object* json, const char* name,
                            (strcmp(uri->scheme, "ipv6") == 0))) {
     const char* host_port = uri->path;
     if (*host_port == '/') ++host_port;
-    grpc_core::UniquePtr<char> host;
-    grpc_core::UniquePtr<char> port;
+    std::string host;
+    std::string port;
     GPR_ASSERT(SplitHostPort(host_port, &host, &port));
     int port_num = -1;
-    if (port != nullptr) {
-      port_num = atoi(port.get());
+    if (!port.empty()) {
+      port_num = atoi(port.data());
     }
-    char* b64_host =
-        grpc_base64_encode(host.get(), strlen(host.get()), false, false);
+    char* b64_host = grpc_base64_encode(host.data(), host.size(), false, false);
     data["tcpip_address"] = Json::Object{
         {"port", port_num},
         {"ip_address", b64_host},
@@ -457,9 +454,7 @@ Json SocketNode::RenderJson() {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_local_stream_created_cycle),
           GPR_CLOCK_REALTIME);
-      char* ts_str = gpr_format_timespec(ts);
-      data["lastLocalStreamCreatedTimestamp"] = ts_str;
-      gpr_free(ts_str);
+      data["lastLocalStreamCreatedTimestamp"] = gpr_format_timespec(ts);
     }
     gpr_cycle_counter last_remote_stream_created_cycle =
         last_remote_stream_created_cycle_.Load(MemoryOrder::RELAXED);
@@ -467,9 +462,7 @@ Json SocketNode::RenderJson() {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_remote_stream_created_cycle),
           GPR_CLOCK_REALTIME);
-      char* ts_str = gpr_format_timespec(ts);
-      data["lastRemoteStreamCreatedTimestamp"] = ts_str;
-      gpr_free(ts_str);
+      data["lastRemoteStreamCreatedTimestamp"] = gpr_format_timespec(ts);
     }
   }
   int64_t streams_succeeded = streams_succeeded_.Load(MemoryOrder::RELAXED);
@@ -487,9 +480,7 @@ Json SocketNode::RenderJson() {
         gpr_cycle_counter_to_time(
             last_message_sent_cycle_.Load(MemoryOrder::RELAXED)),
         GPR_CLOCK_REALTIME);
-    char* ts_str = gpr_format_timespec(ts);
-    data["lastMessageSentTimestamp"] = ts_str;
-    gpr_free(ts_str);
+    data["lastMessageSentTimestamp"] = gpr_format_timespec(ts);
   }
   int64_t messages_received = messages_received_.Load(MemoryOrder::RELAXED);
   if (messages_received != 0) {
@@ -498,9 +489,7 @@ Json SocketNode::RenderJson() {
         gpr_cycle_counter_to_time(
             last_message_received_cycle_.Load(MemoryOrder::RELAXED)),
         GPR_CLOCK_REALTIME);
-    char* ts_str = gpr_format_timespec(ts);
-    data["lastMessageReceivedTimestamp"] = ts_str;
-    gpr_free(ts_str);
+    data["lastMessageReceivedTimestamp"] = gpr_format_timespec(ts);
   }
   int64_t keepalives_sent = keepalives_sent_.Load(MemoryOrder::RELAXED);
   if (keepalives_sent != 0) {

data/src/core/lib/channel/channelz.h

@@ -25,10 +25,11 @@
 
 #include <string>
 
+#include "absl/container/inlined_vector.h"
+
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/atomic.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -167,7 +168,7 @@ class CallCountingHelper {
   void CollectData(CounterData* out);
 
   // Really zero-sized, but 0-sized arrays are illegal on MSVC.
-  InlinedVector<AtomicCounterData, 1> per_cpu_counter_data_storage_;
+  absl::InlinedVector<AtomicCounterData, 1> per_cpu_counter_data_storage_;
   size_t num_cores_ = 0;
 };
 

data/src/core/lib/channel/channelz_registry.cc

@@ -21,6 +21,8 @@
 #include <algorithm>
 #include <cstring>
 
+#include "absl/container/inlined_vector.h"
+
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/channelz_registry.h"
@@ -82,7 +84,7 @@ RefCountedPtr ChannelzRegistry::InternalGet(intptr_t uuid) {
 
 std::string ChannelzRegistry::InternalGetTopChannels(
     intptr_t start_channel_id) {
-  InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
+  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
@@ -120,7 +122,7 @@ std::string ChannelzRegistry::InternalGetTopChannels(
 }
 
 std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
-  InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
+  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
@@ -158,7 +160,7 @@ std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
 }
 
 void ChannelzRegistry::InternalLogAllEntities() {
-  InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
+  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
   {
     MutexLock lock(&mu_);
     for (auto& p : node_map_) {

data/src/core/lib/channel/connected_channel.cc

@@ -38,13 +38,12 @@ typedef struct connected_channel_channel_data {
   grpc_transport* transport;
 } channel_data;
 
-typedef struct {
+struct callback_state {
   grpc_closure closure;
   grpc_closure* original_closure;
   grpc_core::CallCombiner* call_combiner;
   const char* reason;
-} callback_state;
-
+};
 typedef struct connected_channel_call_data {
   grpc_core::CallCombiner* call_combiner;
   // Closures used for returning results on the call combiner.
@@ -91,9 +90,12 @@ static callback_state* get_state_for_batch(
 /* We perform a small hack to locate transport data alongside the connected
    channel data in call allocations, to allow everything to be pulled in minimal
    cache line requests */
-#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) ((grpc_stream*)((calld) + 1))
+#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) \
+  ((grpc_stream*)(((char*)(calld)) +           \
+                  GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(call_data))))
 #define CALL_DATA_FROM_TRANSPORT_STREAM(transport_stream) \
-  (((call_data*)(transport_stream)) - 1)
+  ((call_data*)(((char*)(transport_stream)) -             \
+                GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(call_data))))
 
 /* Intercept a call operation and either push it directly up or translate it
    into transport stream operations */

data/src/core/lib/channel/context.h

@@ -35,7 +35,7 @@ typedef enum {
   /// Reserved for traffic_class_context.
   GRPC_CONTEXT_TRAFFIC,
 
-  /// Holds a pointer to ServiceConfig::CallData associated with this call.
+  /// Holds a pointer to ServiceConfigCallData associated with this call.
   GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA,
 
   GRPC_CONTEXT_COUNT

data/src/core/lib/channel/handshaker.cc

@@ -20,6 +20,8 @@
 
 #include <string.h>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/impl/codegen/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -37,19 +39,16 @@ TraceFlag grpc_handshaker_trace(false, "handshaker");
 
 namespace {
 
-char* HandshakerArgsString(HandshakerArgs* args) {
-  char* args_str = grpc_channel_args_string(args->args);
+std::string HandshakerArgsString(HandshakerArgs* args) {
   size_t num_args = args->args != nullptr ? args->args->num_args : 0;
   size_t read_buffer_length =
       args->read_buffer != nullptr ? args->read_buffer->length : 0;
-  char* str;
-  gpr_asprintf(&str,
-               "{endpoint=%p, args=%p {size=%" PRIuPTR
-               ": %s}, read_buffer=%p (length=%" PRIuPTR "), exit_early=%d}",
-               args->endpoint, args->args, num_args, args_str,
-               args->read_buffer, read_buffer_length, args->exit_early);
-  gpr_free(args_str);
-  return str;
+  return absl::StrFormat(
+      "{endpoint=%p, args=%p {size=%" PRIuPTR
+      ": %s}, read_buffer=%p (length=%" PRIuPTR "), exit_early=%d}",
+      args->endpoint, args->args, num_args,
+      grpc_channel_args_string(args->args), args->read_buffer,
+      read_buffer_length, args->exit_early);
 }
 
 }  // namespace
@@ -127,12 +126,11 @@ void HandshakeManager::Shutdown(grpc_error* why) {
 // Returns true if we've scheduled the on_handshake_done callback.
 bool HandshakeManager::CallNextHandshakerLocked(grpc_error* error) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
-    char* args_str = HandshakerArgsString(&args_);
     gpr_log(GPR_INFO,
             "handshake_manager %p: error=%s shutdown=%d index=%" PRIuPTR
             ", args=%s",
-            this, grpc_error_string(error), is_shutdown_, index_, args_str);
-    gpr_free(args_str);
+            this, grpc_error_string(error), is_shutdown_, index_,
+            HandshakerArgsString(&args_).c_str());
   }
   GPR_ASSERT(index_ <= handshakers_.size());
   // If we got an error or we've been shut down or we're exiting early or

data/src/core/lib/channel/handshaker.h

@@ -21,12 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/container/inlined_vector.h"
+
 #include <grpc/support/string_util.h>
 
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -146,7 +147,8 @@ class HandshakeManager : public RefCounted {
   gpr_mu mu_;
   bool is_shutdown_ = false;
   // An array of handshakers added via grpc_handshake_manager_add().
-  InlinedVector<RefCountedPtr<Handshaker>, HANDSHAKERS_INIT_SIZE> handshakers_;
+  absl::InlinedVector<RefCountedPtr<Handshaker>, HANDSHAKERS_INIT_SIZE>
+      handshakers_;
   // The index of the handshaker to invoke next and closure to invoke it.
   size_t index_ = 0;
   grpc_closure call_next_handshaker_;

data/src/core/lib/channel/handshaker_registry.cc

@@ -18,9 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/container/inlined_vector.h"
+
 #include "src/core/lib/channel/handshaker_registry.h"
 #include "src/core/lib/gpr/alloc.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/memory.h"
 
 #include <string.h>
@@ -44,7 +45,7 @@ class HandshakerFactoryList {
                       HandshakeManager* handshake_mgr);
 
  private:
-  InlinedVector<std::unique_ptr<HandshakerFactory>, 2> factories_;
+  absl::InlinedVector<std::unique_ptr<HandshakerFactory>, 2> factories_;
 };
 
 HandshakerFactoryList* g_handshaker_factory_lists = nullptr;
@@ -75,25 +76,12 @@ void HandshakerFactoryList::AddHandshakers(const grpc_channel_args* args,
 
 void HandshakerRegistry::Init() {
   GPR_ASSERT(g_handshaker_factory_lists == nullptr);
-  g_handshaker_factory_lists =
-      static_cast<HandshakerFactoryList*>(gpr_malloc_aligned(
-          sizeof(*g_handshaker_factory_lists) * NUM_HANDSHAKER_TYPES,
-          GPR_MAX_ALIGNMENT));
-
-  GPR_ASSERT(g_handshaker_factory_lists != nullptr);
-  for (auto idx = 0; idx < NUM_HANDSHAKER_TYPES; ++idx) {
-    auto factory_list = g_handshaker_factory_lists + idx;
-    new (factory_list) HandshakerFactoryList();
-  }
+  g_handshaker_factory_lists = new HandshakerFactoryList[NUM_HANDSHAKER_TYPES];
 }
 
 void HandshakerRegistry::Shutdown() {
   GPR_ASSERT(g_handshaker_factory_lists != nullptr);
-  for (auto idx = 0; idx < NUM_HANDSHAKER_TYPES; ++idx) {
-    auto factory_list = g_handshaker_factory_lists + idx;
-    factory_list->~HandshakerFactoryList();
-  }
-  gpr_free_aligned(g_handshaker_factory_lists);
+  delete[] g_handshaker_factory_lists;
   g_handshaker_factory_lists = nullptr;
 }