grpc 1.25.0 → 1.26.0

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

@@ -32,6 +32,7 @@
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/error.h"
@@ -54,7 +55,7 @@ namespace channelz {
 namespace {
 
 void* parent_uuid_copy(void* p) { return p; }
-void parent_uuid_destroy(void* p) {}
+void parent_uuid_destroy(void* /*p*/) {}
 int parent_uuid_cmp(void* p1, void* p2) { return GPR_ICMP(p1, p2); }
 const grpc_arg_pointer_vtable parent_uuid_vtable = {
     parent_uuid_copy, parent_uuid_destroy, parent_uuid_cmp};
@@ -85,7 +86,7 @@ intptr_t GetParentUuidFromArgs(const grpc_channel_args& args) {
 // BaseNode
 //
 
-BaseNode::BaseNode(EntityType type, UniquePtr<char> name)
+BaseNode::BaseNode(EntityType type, std::string name)
     : type_(type), uuid_(-1), name_(std::move(name)) {
   // The registry will set uuid_ under its lock.
   ChannelzRegistry::Register(this);
@@ -180,11 +181,11 @@ void CallCountingHelper::PopulateCallCounts(grpc_json* json) {
 // ChannelNode
 //
 
-ChannelNode::ChannelNode(UniquePtr<char> target,
-                         size_t channel_tracer_max_nodes, intptr_t parent_uuid)
+ChannelNode::ChannelNode(std::string target, size_t channel_tracer_max_nodes,
+                         intptr_t parent_uuid)
     : BaseNode(parent_uuid == 0 ? EntityType::kTopLevelChannel
                                 : EntityType::kInternalChannel,
-               UniquePtr<char>(gpr_strdup(target.get()))),
+               target),
       target_(std::move(target)),
       trace_(channel_tracer_max_nodes),
       parent_uuid_(parent_uuid) {}
@@ -239,8 +240,8 @@ grpc_json* ChannelNode::RenderJson() {
     json = data;
   }
   // populate the target.
-  GPR_ASSERT(target_.get() != nullptr);
-  grpc_json_create_child(nullptr, json, "target", target_.get(),
+  GPR_ASSERT(!target_.empty());
+  grpc_json_create_child(nullptr, json, "target", target_.c_str(),
                          GRPC_JSON_STRING, false);
   // fill in the channel trace if applicable
   grpc_json* trace_json = trace_.RenderJson();
@@ -315,9 +316,8 @@ void ChannelNode::RemoveChildSubchannel(intptr_t child_uuid) {
 // ServerNode
 //
 
-ServerNode::ServerNode(grpc_server* server, size_t channel_tracer_max_nodes)
-    : BaseNode(EntityType::kServer, /* name */ nullptr),
-      trace_(channel_tracer_max_nodes) {}
+ServerNode::ServerNode(grpc_server* /*server*/, size_t channel_tracer_max_nodes)
+    : BaseNode(EntityType::kServer, ""), trace_(channel_tracer_max_nodes) {}
 
 ServerNode::~ServerNode() {}
 
@@ -363,7 +363,8 @@ char* ServerNode::RenderServerSockets(intptr_t start_socket_id,
       json_iterator = grpc_json_add_number_string_child(
           socket_ref_json, nullptr, "socketId", it->first);
       grpc_json_create_child(json_iterator, socket_ref_json, "name",
-                             it->second->name(), GRPC_JSON_STRING, false);
+                             it->second->name().c_str(), GRPC_JSON_STRING,
+                             false);
     }
   }
   if (sockets_rendered == child_sockets_.size()) {
@@ -416,7 +417,8 @@ grpc_json* ServerNode::RenderJson() {
       grpc_json* sibling_iterator = grpc_json_add_number_string_child(
           json_iterator, nullptr, "socketId", it.first);
       grpc_json_create_child(sibling_iterator, json_iterator, "name",
-                             it.second->name(), GRPC_JSON_STRING, false);
+                             it.second->name().c_str(), GRPC_JSON_STRING,
+                             false);
     }
   }
   return top_level_json;
@@ -441,8 +443,8 @@ void PopulateSocketAddressJson(grpc_json* json, const char* name,
                            (strcmp(uri->scheme, "ipv6") == 0))) {
     const char* host_port = uri->path;
     if (*host_port == '/') ++host_port;
-    UniquePtr<char> host;
-    UniquePtr<char> port;
+    grpc_core::UniquePtr<char> host;
+    grpc_core::UniquePtr<char> port;
     GPR_ASSERT(SplitHostPort(host_port, &host, &port));
     int port_num = -1;
     if (port != nullptr) {
@@ -479,33 +481,32 @@ void PopulateSocketAddressJson(grpc_json* json, const char* name,
 
 }  // namespace
 
-SocketNode::SocketNode(UniquePtr<char> local, UniquePtr<char> remote,
-                       UniquePtr<char> name)
+SocketNode::SocketNode(std::string local, std::string remote, std::string name)
     : BaseNode(EntityType::kSocket, std::move(name)),
       local_(std::move(local)),
       remote_(std::move(remote)) {}
 
 void SocketNode::RecordStreamStartedFromLocal() {
-  gpr_atm_no_barrier_fetch_add(&streams_started_, static_cast<gpr_atm>(1));
-  gpr_atm_no_barrier_store(&last_local_stream_created_cycle_,
-                           gpr_get_cycle_counter());
+  streams_started_.FetchAdd(1, MemoryOrder::RELAXED);
+  last_local_stream_created_cycle_.Store(gpr_get_cycle_counter(),
+                                         MemoryOrder::RELAXED);
 }
 
 void SocketNode::RecordStreamStartedFromRemote() {
-  gpr_atm_no_barrier_fetch_add(&streams_started_, static_cast<gpr_atm>(1));
-  gpr_atm_no_barrier_store(&last_remote_stream_created_cycle_,
-                           gpr_get_cycle_counter());
+  streams_started_.FetchAdd(1, MemoryOrder::RELAXED);
+  last_remote_stream_created_cycle_.Store(gpr_get_cycle_counter(),
+                                          MemoryOrder::RELAXED);
 }
 
 void SocketNode::RecordMessagesSent(uint32_t num_sent) {
-  gpr_atm_no_barrier_fetch_add(&messages_sent_, static_cast<gpr_atm>(num_sent));
-  gpr_atm_no_barrier_store(&last_message_sent_cycle_, gpr_get_cycle_counter());
+  messages_sent_.FetchAdd(num_sent, MemoryOrder::RELAXED);
+  last_message_sent_cycle_.Store(gpr_get_cycle_counter(), MemoryOrder::RELAXED);
 }
 
 void SocketNode::RecordMessageReceived() {
-  gpr_atm_no_barrier_fetch_add(&messages_received_, static_cast<gpr_atm>(1));
-  gpr_atm_no_barrier_store(&last_message_received_cycle_,
-                           gpr_get_cycle_counter());
+  messages_received_.FetchAdd(1, MemoryOrder::RELAXED);
+  last_message_received_cycle_.Store(gpr_get_cycle_counter(),
+                                     MemoryOrder::RELAXED);
 }
 
 grpc_json* SocketNode::RenderJson() {
@@ -520,11 +521,11 @@ grpc_json* SocketNode::RenderJson() {
   json_iterator = nullptr;
   json_iterator = grpc_json_add_number_string_child(json, json_iterator,
                                                     "socketId", uuid());
-  json_iterator = grpc_json_create_child(json_iterator, json, "name", name(),
-                                         GRPC_JSON_STRING, false);
+  json_iterator = grpc_json_create_child(
+      json_iterator, json, "name", name().c_str(), GRPC_JSON_STRING, false);
   json = top_level_json;
-  PopulateSocketAddressJson(json, "remote", remote_.get());
-  PopulateSocketAddressJson(json, "local", local_.get());
+  PopulateSocketAddressJson(json, "remote", remote_.c_str());
+  PopulateSocketAddressJson(json, "local", local_.c_str());
   // reset json iterators to top level object
   json = top_level_json;
   json_iterator = nullptr;
@@ -534,12 +535,12 @@ grpc_json* SocketNode::RenderJson() {
   json = data;
   json_iterator = nullptr;
   gpr_timespec ts;
-  gpr_atm streams_started = gpr_atm_no_barrier_load(&streams_started_);
+  int64_t streams_started = streams_started_.Load(MemoryOrder::RELAXED);
   if (streams_started != 0) {
     json_iterator = grpc_json_add_number_string_child(
         json, json_iterator, "streamsStarted", streams_started);
     gpr_cycle_counter last_local_stream_created_cycle =
-        gpr_atm_no_barrier_load(&last_local_stream_created_cycle_);
+        last_local_stream_created_cycle_.Load(MemoryOrder::RELAXED);
     if (last_local_stream_created_cycle != 0) {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_local_stream_created_cycle),
@@ -549,7 +550,7 @@ grpc_json* SocketNode::RenderJson() {
           gpr_format_timespec(ts), GRPC_JSON_STRING, true);
     }
     gpr_cycle_counter last_remote_stream_created_cycle =
-        gpr_atm_no_barrier_load(&last_remote_stream_created_cycle_);
+        last_remote_stream_created_cycle_.Load(MemoryOrder::RELAXED);
     if (last_remote_stream_created_cycle != 0) {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_remote_stream_created_cycle),
@@ -559,41 +560,41 @@ grpc_json* SocketNode::RenderJson() {
           gpr_format_timespec(ts), GRPC_JSON_STRING, true);
     }
   }
-  gpr_atm streams_succeeded = gpr_atm_no_barrier_load(&streams_succeeded_);
+  int64_t streams_succeeded = streams_succeeded_.Load(MemoryOrder::RELAXED);
   if (streams_succeeded != 0) {
     json_iterator = grpc_json_add_number_string_child(
         json, json_iterator, "streamsSucceeded", streams_succeeded);
   }
-  gpr_atm streams_failed = gpr_atm_no_barrier_load(&streams_failed_);
+  int64_t streams_failed = streams_failed_.Load(MemoryOrder::RELAXED);
   if (streams_failed) {
     json_iterator = grpc_json_add_number_string_child(
         json, json_iterator, "streamsFailed", streams_failed);
   }
-  gpr_atm messages_sent = gpr_atm_no_barrier_load(&messages_sent_);
+  int64_t messages_sent = messages_sent_.Load(MemoryOrder::RELAXED);
   if (messages_sent != 0) {
     json_iterator = grpc_json_add_number_string_child(
         json, json_iterator, "messagesSent", messages_sent);
     ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(
-            gpr_atm_no_barrier_load(&last_message_sent_cycle_)),
+            last_message_sent_cycle_.Load(MemoryOrder::RELAXED)),
         GPR_CLOCK_REALTIME);
     json_iterator =
         grpc_json_create_child(json_iterator, json, "lastMessageSentTimestamp",
                                gpr_format_timespec(ts), GRPC_JSON_STRING, true);
   }
-  gpr_atm messages_received = gpr_atm_no_barrier_load(&messages_received_);
+  int64_t messages_received = messages_received_.Load(MemoryOrder::RELAXED);
   if (messages_received != 0) {
     json_iterator = grpc_json_add_number_string_child(
         json, json_iterator, "messagesReceived", messages_received);
     ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(
-            gpr_atm_no_barrier_load(&last_message_received_cycle_)),
+            last_message_received_cycle_.Load(MemoryOrder::RELAXED)),
         GPR_CLOCK_REALTIME);
     json_iterator = grpc_json_create_child(
         json_iterator, json, "lastMessageReceivedTimestamp",
         gpr_format_timespec(ts), GRPC_JSON_STRING, true);
   }
-  gpr_atm keepalives_sent = gpr_atm_no_barrier_load(&keepalives_sent_);
+  int64_t keepalives_sent = keepalives_sent_.Load(MemoryOrder::RELAXED);
   if (keepalives_sent != 0) {
     json_iterator = grpc_json_add_number_string_child(
         json, json_iterator, "keepAlivesSent", keepalives_sent);
@@ -605,8 +606,7 @@ grpc_json* SocketNode::RenderJson() {
 // ListenSocketNode
 //
 
-ListenSocketNode::ListenSocketNode(UniquePtr<char> local_addr,
-                                   UniquePtr<char> name)
+ListenSocketNode::ListenSocketNode(std::string local_addr, std::string name)
     : BaseNode(EntityType::kSocket, std::move(name)),
       local_addr_(std::move(local_addr)) {}
 
@@ -622,10 +622,10 @@ grpc_json* ListenSocketNode::RenderJson() {
   json_iterator = nullptr;
   json_iterator = grpc_json_add_number_string_child(json, json_iterator,
                                                     "socketId", uuid());
-  json_iterator = grpc_json_create_child(json_iterator, json, "name", name(),
-                                         GRPC_JSON_STRING, false);
+  json_iterator = grpc_json_create_child(
+      json_iterator, json, "name", name().c_str(), GRPC_JSON_STRING, false);
   json = top_level_json;
-  PopulateSocketAddressJson(json, "local", local_addr_.get());
+  PopulateSocketAddressJson(json, "local", local_addr_.c_str());
 
   return top_level_json;
 }

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

@@ -23,8 +23,11 @@
 
 #include <grpc/grpc.h>
 
+#include <string>
+
 #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"
@@ -82,7 +85,7 @@ class BaseNode : public RefCounted<BaseNode> {
   };
 
  protected:
-  BaseNode(EntityType type, UniquePtr<char> name);
+  BaseNode(EntityType type, std::string name);
 
  public:
   virtual ~BaseNode();
@@ -96,14 +99,14 @@ class BaseNode : public RefCounted<BaseNode> {
 
   EntityType type() const { return type_; }
   intptr_t uuid() const { return uuid_; }
-  const char* name() const { return name_.get(); }
+  const std::string& name() const { return name_; }
 
  private:
   // to allow the ChannelzRegistry to set uuid_ under its lock.
   friend class ChannelzRegistry;
   const EntityType type_;
   intptr_t uuid_;
-  UniquePtr<char> name_;
+  std::string name_;
 };
 
 // This class is a helper class for channelz entities that deal with Channels,
@@ -138,9 +141,9 @@ class CallCountingHelper {
           last_call_started_cycle(
               that.last_call_started_cycle.Load(MemoryOrder::RELAXED)) {}
 
-    Atomic<intptr_t> calls_started{0};
-    Atomic<intptr_t> calls_succeeded{0};
-    Atomic<intptr_t> calls_failed{0};
+    Atomic<int64_t> calls_started{0};
+    Atomic<int64_t> calls_succeeded{0};
+    Atomic<int64_t> calls_failed{0};
     Atomic<gpr_cycle_counter> last_call_started_cycle{0};
     // Make sure the size is exactly one cache line.
     uint8_t padding[GPR_CACHELINE_SIZE - 3 * sizeof(Atomic<intptr_t>) -
@@ -148,9 +151,9 @@ class CallCountingHelper {
   } GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
 
   struct CounterData {
-    intptr_t calls_started = 0;
-    intptr_t calls_succeeded = 0;
-    intptr_t calls_failed = 0;
+    int64_t calls_started = 0;
+    int64_t calls_succeeded = 0;
+    int64_t calls_failed = 0;
     gpr_cycle_counter last_call_started_cycle = 0;
   };
 
@@ -165,7 +168,7 @@ class CallCountingHelper {
 // Handles channelz bookkeeping for channels
 class ChannelNode : public BaseNode {
  public:
-  ChannelNode(UniquePtr<char> target, size_t channel_tracer_max_nodes,
+  ChannelNode(std::string target, size_t channel_tracer_max_nodes,
               intptr_t parent_uuid);
 
   // Returns the string description of the given connectivity state.
@@ -208,7 +211,7 @@ class ChannelNode : public BaseNode {
   // to allow the channel trace test to access trace_.
   friend class testing::ChannelNodePeer;
 
-  UniquePtr<char> target_;
+  std::string target_;
   CallCountingHelper call_counter_;
   ChannelTrace trace_;
   const intptr_t parent_uuid_;
@@ -221,8 +224,8 @@ class ChannelNode : public BaseNode {
   // TODO(roth): We don't actually use the values here, only the keys, so
   // these should be sets instead of maps, but we don't currently have a set
   // implementation.  Change this if/when we have one.
-  Map<intptr_t, bool> child_channels_;
-  Map<intptr_t, bool> child_subchannels_;
+  std::map<intptr_t, bool> child_channels_;
+  std::map<intptr_t, bool> child_subchannels_;
 };
 
 // Handles channelz bookkeeping for servers
@@ -262,15 +265,14 @@ class ServerNode : public BaseNode {
   CallCountingHelper call_counter_;
   ChannelTrace trace_;
   Mutex child_mu_;  // Guards child maps below.
-  Map<intptr_t, RefCountedPtr<SocketNode>> child_sockets_;
-  Map<intptr_t, RefCountedPtr<ListenSocketNode>> child_listen_sockets_;
+  std::map<intptr_t, RefCountedPtr<SocketNode>> child_sockets_;
+  std::map<intptr_t, RefCountedPtr<ListenSocketNode>> child_listen_sockets_;
 };
 
 // Handles channelz bookkeeping for sockets
 class SocketNode : public BaseNode {
  public:
-  SocketNode(UniquePtr<char> local, UniquePtr<char> remote,
-             UniquePtr<char> name);
+  SocketNode(std::string local, std::string remote, std::string name);
   ~SocketNode() override {}
 
   grpc_json* RenderJson() override;
@@ -278,44 +280,44 @@ class SocketNode : public BaseNode {
   void RecordStreamStartedFromLocal();
   void RecordStreamStartedFromRemote();
   void RecordStreamSucceeded() {
-    gpr_atm_no_barrier_fetch_add(&streams_succeeded_, static_cast<gpr_atm>(1));
+    streams_succeeded_.FetchAdd(1, MemoryOrder::RELAXED);
   }
   void RecordStreamFailed() {
-    gpr_atm_no_barrier_fetch_add(&streams_failed_, static_cast<gpr_atm>(1));
+    streams_failed_.FetchAdd(1, MemoryOrder::RELAXED);
   }
   void RecordMessagesSent(uint32_t num_sent);
   void RecordMessageReceived();
   void RecordKeepaliveSent() {
-    gpr_atm_no_barrier_fetch_add(&keepalives_sent_, static_cast<gpr_atm>(1));
+    keepalives_sent_.FetchAdd(1, MemoryOrder::RELAXED);
   }
 
-  const char* remote() { return remote_.get(); }
+  const std::string& remote() { return remote_; }
 
  private:
-  gpr_atm streams_started_ = 0;
-  gpr_atm streams_succeeded_ = 0;
-  gpr_atm streams_failed_ = 0;
-  gpr_atm messages_sent_ = 0;
-  gpr_atm messages_received_ = 0;
-  gpr_atm keepalives_sent_ = 0;
-  gpr_atm last_local_stream_created_cycle_ = 0;
-  gpr_atm last_remote_stream_created_cycle_ = 0;
-  gpr_atm last_message_sent_cycle_ = 0;
-  gpr_atm last_message_received_cycle_ = 0;
-  UniquePtr<char> local_;
-  UniquePtr<char> remote_;
+  Atomic<int64_t> streams_started_{0};
+  Atomic<int64_t> streams_succeeded_{0};
+  Atomic<int64_t> streams_failed_{0};
+  Atomic<int64_t> messages_sent_{0};
+  Atomic<int64_t> messages_received_{0};
+  Atomic<int64_t> keepalives_sent_{0};
+  Atomic<gpr_cycle_counter> last_local_stream_created_cycle_{0};
+  Atomic<gpr_cycle_counter> last_remote_stream_created_cycle_{0};
+  Atomic<gpr_cycle_counter> last_message_sent_cycle_{0};
+  Atomic<gpr_cycle_counter> last_message_received_cycle_{0};
+  std::string local_;
+  std::string remote_;
 };
 
 // Handles channelz bookkeeping for listen sockets
 class ListenSocketNode : public BaseNode {
  public:
-  ListenSocketNode(UniquePtr<char> local_addr, UniquePtr<char> name);
+  ListenSocketNode(std::string local_addr, std::string name);
   ~ListenSocketNode() override {}
 
   grpc_json* RenderJson() override;
 
  private:
-  UniquePtr<char> local_addr_;
+  std::string local_addr_;
 };
 
 }  // namespace channelz

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

@@ -43,9 +43,9 @@ const int kPaginationLimit = 100;
 
 }  // anonymous namespace
 
-void ChannelzRegistry::Init() { g_channelz_registry = New<ChannelzRegistry>(); }
+void ChannelzRegistry::Init() { g_channelz_registry = new ChannelzRegistry(); }
 
-void ChannelzRegistry::Shutdown() { Delete(g_channelz_registry); }
+void ChannelzRegistry::Shutdown() { delete g_channelz_registry; }
 
 ChannelzRegistry* ChannelzRegistry::Default() {
   GPR_DEBUG_ASSERT(g_channelz_registry != nullptr);

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

@@ -87,7 +87,7 @@ class ChannelzRegistry {
 
   // protects members
   Mutex mu_;
-  Map<intptr_t, BaseNode*> node_map_;
+  std::map<intptr_t, BaseNode*> node_map_;
   intptr_t uuid_generator_ = 0;
 };
 

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

@@ -167,7 +167,7 @@ static void set_pollset_or_pollset_set(grpc_call_element* elem,
 
 /* Destructor for call_data */
 static void connected_channel_destroy_call_elem(
-    grpc_call_element* elem, const grpc_call_final_info* final_info,
+    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
     grpc_closure* then_schedule_closure) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
@@ -195,7 +195,8 @@ static void connected_channel_destroy_channel_elem(grpc_channel_element* elem) {
 
 /* No-op. */
 static void connected_channel_get_channel_info(
-    grpc_channel_element* elem, const grpc_channel_info* channel_info) {}
+    grpc_channel_element* /*elem*/, const grpc_channel_info* /*channel_info*/) {
+}
 
 const grpc_channel_filter grpc_connected_filter = {
     connected_channel_start_transport_stream_op_batch,