grpc 1.21.0 → 1.22.0

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

@@ -26,19 +26,19 @@
 #include "src/core/lib/channel/channel_trace.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"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/json/json.h"
 
-// Channel arg key for client channel factory.
-#define GRPC_ARG_CHANNELZ_CHANNEL_NODE_CREATION_FUNC \
-  "grpc.channelz_channel_node_creation_func"
+// Channel arg key for channelz node.
+#define GRPC_ARG_CHANNELZ_CHANNEL_NODE "grpc.channelz_channel_node"
 
-// Channel arg key to signal that the channel is an internal channel.
-#define GRPC_ARG_CHANNELZ_CHANNEL_IS_INTERNAL_CHANNEL \
-  "grpc.channelz_channel_is_internal_channel"
+// Channel arg key to encode the channelz uuid of the channel's parent.
+#define GRPC_ARG_CHANNELZ_PARENT_UUID "grpc.channelz_parent_uuid"
 
 /** This is the default value for whether or not to enable channelz. If
  * GRPC_ARG_ENABLE_CHANNELZ is set, it will override this default value. */
@@ -54,6 +54,10 @@ namespace grpc_core {
 
 namespace channelz {
 
+// Helpers for getting and setting GRPC_ARG_CHANNELZ_PARENT_UUID.
+grpc_arg MakeParentUuidArg(intptr_t parent_uuid);
+intptr_t GetParentUuidFromArgs(const grpc_channel_args& args);
+
 // TODO(ncteisen), this only contains the uuids of the children for now,
 // since that is all that is strictly needed. In a future enhancement we will
 // add human readable names as in the channelz.proto
@@ -147,38 +151,13 @@ class CallCountingHelper {
 // Handles channelz bookkeeping for channels
 class ChannelNode : public BaseNode {
  public:
-  static RefCountedPtr<ChannelNode> MakeChannelNode(
-      grpc_channel* channel, size_t channel_tracer_max_nodes,
-      bool is_top_level_channel);
+  ChannelNode(UniquePtr<char> target, size_t channel_tracer_max_nodes,
+              intptr_t parent_uuid);
 
-  ChannelNode(grpc_channel* channel, size_t channel_tracer_max_nodes,
-              bool is_top_level_channel);
-  ~ChannelNode() override;
+  intptr_t parent_uuid() const { return parent_uuid_; }
 
   grpc_json* RenderJson() override;
 
-  // template methods. RenderJSON uses these methods to render its JSON
-  // representation. These are virtual so that children classes may provide
-  // their specific mechanism for populating these parts of the channelz
-  // object.
-  //
-  // ChannelNode does not have a notion of connectivity state or child refs,
-  // so it leaves these implementations blank.
-  //
-  // This is utilizing the template method design pattern.
-  //
-  // TODO(ncteisen): remove these template methods in favor of manual traversal
-  // and mutation of the grpc_json object.
-  virtual void PopulateConnectivityState(grpc_json* json) {}
-  virtual void PopulateChildRefs(grpc_json* json) {}
-
-  void MarkChannelDestroyed() {
-    GPR_ASSERT(channel_ != nullptr);
-    channel_ = nullptr;
-  }
-
-  bool ChannelIsDestroyed() { return channel_ == nullptr; }
-
   // proxy methods to composed classes.
   void AddTraceEvent(ChannelTrace::Severity severity, const grpc_slice& data) {
     trace_.AddTraceEvent(severity, data);
@@ -193,13 +172,35 @@ class ChannelNode : public BaseNode {
   void RecordCallFailed() { call_counter_.RecordCallFailed(); }
   void RecordCallSucceeded() { call_counter_.RecordCallSucceeded(); }
 
+  void SetConnectivityState(grpc_connectivity_state state);
+
+  void AddChildChannel(intptr_t child_uuid);
+  void RemoveChildChannel(intptr_t child_uuid);
+
+  void AddChildSubchannel(intptr_t child_uuid);
+  void RemoveChildSubchannel(intptr_t child_uuid);
+
  private:
+  void PopulateChildRefs(grpc_json* json);
+
   // to allow the channel trace test to access trace_.
   friend class testing::ChannelNodePeer;
-  grpc_channel* channel_ = nullptr;
+
   UniquePtr<char> target_;
   CallCountingHelper call_counter_;
   ChannelTrace trace_;
+  const intptr_t parent_uuid_;
+
+  // Least significant bit indicates whether the value is set.  Remaining
+  // bits are a grpc_connectivity_state value.
+  Atomic<int> connectivity_state_{0};
+
+  Mutex child_mu_;  // Guards child maps below.
+  // 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_;
 };
 
 // Handles channelz bookkeeping for servers
@@ -285,11 +286,6 @@ class ListenSocketNode : public BaseNode {
   UniquePtr<char> local_addr_;
 };
 
-// Creation functions
-
-typedef RefCountedPtr<ChannelNode> (*ChannelNodeCreationFunc)(grpc_channel*,
-                                                              size_t, bool);
-
 }  // namespace channelz
 }  // namespace grpc_core
 

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

@@ -18,6 +18,9 @@
 
 #include <grpc/impl/codegen/port_platform.h>
 
+#include <algorithm>
+#include <cstring>
+
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/channelz_registry.h"
@@ -29,8 +32,6 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include <cstring>
-
 namespace grpc_core {
 namespace channelz {
 namespace {
@@ -51,102 +52,58 @@ ChannelzRegistry* ChannelzRegistry::Default() {
   return g_channelz_registry;
 }
 
-ChannelzRegistry::ChannelzRegistry() { gpr_mu_init(&mu_); }
-
-ChannelzRegistry::~ChannelzRegistry() { gpr_mu_destroy(&mu_); }
-
 void ChannelzRegistry::InternalRegister(BaseNode* node) {
   MutexLock lock(&mu_);
-  entities_.push_back(node);
   node->uuid_ = ++uuid_generator_;
-}
-
-void ChannelzRegistry::MaybePerformCompactionLocked() {
-  constexpr double kEmptinessTheshold = 1. / 3;
-  double emptiness_ratio =
-      double(num_empty_slots_) / double(entities_.capacity());
-  if (emptiness_ratio > kEmptinessTheshold) {
-    int front = 0;
-    for (size_t i = 0; i < entities_.size(); ++i) {
-      if (entities_[i] != nullptr) {
-        entities_[front++] = entities_[i];
-      }
-    }
-    for (int i = 0; i < num_empty_slots_; ++i) {
-      entities_.pop_back();
-    }
-    num_empty_slots_ = 0;
-  }
-}
-
-int ChannelzRegistry::FindByUuidLocked(intptr_t target_uuid,
-                                       bool direct_hit_needed) {
-  int left = 0;
-  int right = int(entities_.size() - 1);
-  while (left <= right) {
-    int true_middle = left + (right - left) / 2;
-    int first_non_null = true_middle;
-    while (first_non_null < right && entities_[first_non_null] == nullptr) {
-      first_non_null++;
-    }
-    if (entities_[first_non_null] == nullptr) {
-      right = true_middle - 1;
-      continue;
-    }
-    intptr_t uuid = entities_[first_non_null]->uuid();
-    if (uuid == target_uuid) {
-      return int(first_non_null);
-    }
-    if (uuid < target_uuid) {
-      left = first_non_null + 1;
-    } else {
-      right = true_middle - 1;
-    }
-  }
-  return direct_hit_needed ? -1 : left;
+  node_map_[node->uuid_] = node;
 }
 
 void ChannelzRegistry::InternalUnregister(intptr_t uuid) {
   GPR_ASSERT(uuid >= 1);
   MutexLock lock(&mu_);
   GPR_ASSERT(uuid <= uuid_generator_);
-  int idx = FindByUuidLocked(uuid, true);
-  GPR_ASSERT(idx >= 0);
-  entities_[idx] = nullptr;
-  num_empty_slots_++;
-  MaybePerformCompactionLocked();
+  node_map_.erase(uuid);
 }
 
-BaseNode* ChannelzRegistry::InternalGet(intptr_t uuid) {
+RefCountedPtr<BaseNode> ChannelzRegistry::InternalGet(intptr_t uuid) {
   MutexLock lock(&mu_);
   if (uuid < 1 || uuid > uuid_generator_) {
     return nullptr;
   }
-  int idx = FindByUuidLocked(uuid, true);
-  return idx < 0 ? nullptr : entities_[idx];
+  auto it = node_map_.find(uuid);
+  if (it == node_map_.end()) return nullptr;
+  // Found node.  Return only if its refcount is not zero (i.e., when we
+  // know that there is no other thread about to destroy it).
+  BaseNode* node = it->second;
+  if (!node->RefIfNonZero()) return nullptr;
+  return RefCountedPtr<BaseNode>(node);
 }
 
 char* ChannelzRegistry::InternalGetTopChannels(intptr_t start_channel_id) {
-  MutexLock lock(&mu_);
   grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
   grpc_json* json = top_level_json;
   grpc_json* json_iterator = nullptr;
-  InlinedVector<BaseNode*, 10> top_level_channels;
-  bool reached_pagination_limit = false;
-  int start_idx = GPR_MAX(FindByUuidLocked(start_channel_id, false), 0);
-  for (size_t i = start_idx; i < entities_.size(); ++i) {
-    if (entities_[i] != nullptr &&
-        entities_[i]->type() ==
-            grpc_core::channelz::BaseNode::EntityType::kTopLevelChannel &&
-        entities_[i]->uuid() >= start_channel_id) {
-      // check if we are over pagination limit to determine if we need to set
-      // the "end" element. If we don't go through this block, we know that
-      // when the loop terminates, we have <= to kPaginationLimit.
-      if (top_level_channels.size() == kPaginationLimit) {
-        reached_pagination_limit = true;
-        break;
+  InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
+  RefCountedPtr<BaseNode> node_after_pagination_limit;
+  {
+    MutexLock lock(&mu_);
+    for (auto it = node_map_.lower_bound(start_channel_id);
+         it != node_map_.end(); ++it) {
+      BaseNode* node = it->second;
+      if (node->type() == BaseNode::EntityType::kTopLevelChannel &&
+          node->RefIfNonZero()) {
+        // Check if we are over pagination limit to determine if we need to set
+        // the "end" element. If we don't go through this block, we know that
+        // when the loop terminates, we have <= to kPaginationLimit.
+        // Note that because we have already increased this node's
+        // refcount, we need to decrease it, but we can't unref while
+        // holding the lock, because this may lead to a deadlock.
+        if (top_level_channels.size() == kPaginationLimit) {
+          node_after_pagination_limit.reset(node);
+          break;
+        }
+        top_level_channels.emplace_back(node);
       }
-      top_level_channels.push_back(entities_[i]);
     }
   }
   if (!top_level_channels.empty()) {
@@ -159,7 +116,7 @@ char* ChannelzRegistry::InternalGetTopChannels(intptr_t start_channel_id) {
           grpc_json_link_child(array_parent, channel_json, json_iterator);
     }
   }
-  if (!reached_pagination_limit) {
+  if (node_after_pagination_limit == nullptr) {
     grpc_json_create_child(nullptr, json, "end", nullptr, GRPC_JSON_TRUE,
                            false);
   }
@@ -169,26 +126,30 @@ char* ChannelzRegistry::InternalGetTopChannels(intptr_t start_channel_id) {
 }
 
 char* ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
-  MutexLock lock(&mu_);
   grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
   grpc_json* json = top_level_json;
   grpc_json* json_iterator = nullptr;
-  InlinedVector<BaseNode*, 10> servers;
-  bool reached_pagination_limit = false;
-  int start_idx = GPR_MAX(FindByUuidLocked(start_server_id, false), 0);
-  for (size_t i = start_idx; i < entities_.size(); ++i) {
-    if (entities_[i] != nullptr &&
-        entities_[i]->type() ==
-            grpc_core::channelz::BaseNode::EntityType::kServer &&
-        entities_[i]->uuid() >= start_server_id) {
-      // check if we are over pagination limit to determine if we need to set
-      // the "end" element. If we don't go through this block, we know that
-      // when the loop terminates, we have <= to kPaginationLimit.
-      if (servers.size() == kPaginationLimit) {
-        reached_pagination_limit = true;
-        break;
+  InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
+  RefCountedPtr<BaseNode> node_after_pagination_limit;
+  {
+    MutexLock lock(&mu_);
+    for (auto it = node_map_.lower_bound(start_server_id);
+         it != node_map_.end(); ++it) {
+      BaseNode* node = it->second;
+      if (node->type() == BaseNode::EntityType::kServer &&
+          node->RefIfNonZero()) {
+        // Check if we are over pagination limit to determine if we need to set
+        // the "end" element. If we don't go through this block, we know that
+        // when the loop terminates, we have <= to kPaginationLimit.
+        // Note that because we have already increased this node's
+        // refcount, we need to decrease it, but we can't unref while
+        // holding the lock, because this may lead to a deadlock.
+        if (servers.size() == kPaginationLimit) {
+          node_after_pagination_limit.reset(node);
+          break;
+        }
+        servers.emplace_back(node);
       }
-      servers.push_back(entities_[i]);
     }
   }
   if (!servers.empty()) {
@@ -201,7 +162,7 @@ char* ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
           grpc_json_link_child(array_parent, server_json, json_iterator);
     }
   }
-  if (!reached_pagination_limit) {
+  if (node_after_pagination_limit == nullptr) {
     grpc_json_create_child(nullptr, json, "end", nullptr, GRPC_JSON_TRUE,
                            false);
   }
@@ -211,14 +172,21 @@ char* ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
 }
 
 void ChannelzRegistry::InternalLogAllEntities() {
-  MutexLock lock(&mu_);
-  for (size_t i = 0; i < entities_.size(); ++i) {
-    if (entities_[i] != nullptr) {
-      char* json = entities_[i]->RenderJsonString();
-      gpr_log(GPR_INFO, "%s", json);
-      gpr_free(json);
+  InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
+  {
+    MutexLock lock(&mu_);
+    for (auto& p : node_map_) {
+      BaseNode* node = p.second;
+      if (node->RefIfNonZero()) {
+        nodes.emplace_back(node);
+      }
     }
   }
+  for (size_t i = 0; i < nodes.size(); ++i) {
+    char* json = nodes[i]->RenderJsonString();
+    gpr_log(GPR_INFO, "%s", json);
+    gpr_free(json);
+  }
 }
 
 }  // namespace channelz
@@ -234,7 +202,7 @@ char* grpc_channelz_get_servers(intptr_t start_server_id) {
 }
 
 char* grpc_channelz_get_server(intptr_t server_id) {
-  grpc_core::channelz::BaseNode* server_node =
+  grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> server_node =
       grpc_core::channelz::ChannelzRegistry::Get(server_id);
   if (server_node == nullptr ||
       server_node->type() !=
@@ -254,7 +222,7 @@ char* grpc_channelz_get_server(intptr_t server_id) {
 char* grpc_channelz_get_server_sockets(intptr_t server_id,
                                        intptr_t start_socket_id,
                                        intptr_t max_results) {
-  grpc_core::channelz::BaseNode* base_node =
+  grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> base_node =
       grpc_core::channelz::ChannelzRegistry::Get(server_id);
   if (base_node == nullptr ||
       base_node->type() != grpc_core::channelz::BaseNode::EntityType::kServer) {
@@ -263,12 +231,12 @@ char* grpc_channelz_get_server_sockets(intptr_t server_id,
   // This cast is ok since we have just checked to make sure base_node is
   // actually a server node
   grpc_core::channelz::ServerNode* server_node =
-      static_cast<grpc_core::channelz::ServerNode*>(base_node);
+      static_cast<grpc_core::channelz::ServerNode*>(base_node.get());
   return server_node->RenderServerSockets(start_socket_id, max_results);
 }
 
 char* grpc_channelz_get_channel(intptr_t channel_id) {
-  grpc_core::channelz::BaseNode* channel_node =
+  grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> channel_node =
       grpc_core::channelz::ChannelzRegistry::Get(channel_id);
   if (channel_node == nullptr ||
       (channel_node->type() !=
@@ -288,7 +256,7 @@ char* grpc_channelz_get_channel(intptr_t channel_id) {
 }
 
 char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
-  grpc_core::channelz::BaseNode* subchannel_node =
+  grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> subchannel_node =
       grpc_core::channelz::ChannelzRegistry::Get(subchannel_id);
   if (subchannel_node == nullptr ||
       subchannel_node->type() !=
@@ -306,7 +274,7 @@ char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
 }
 
 char* grpc_channelz_get_socket(intptr_t socket_id) {
-  grpc_core::channelz::BaseNode* socket_node =
+  grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> socket_node =
       grpc_core::channelz::ChannelzRegistry::Get(socket_id);
   if (socket_node == nullptr ||
       socket_node->type() !=

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

@@ -21,19 +21,16 @@
 
 #include <grpc/impl/codegen/port_platform.h>
 
+#include <stdint.h>
+
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
-
-#include <stdint.h>
+#include "src/core/lib/gprpp/map.h"
+#include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_core {
 namespace channelz {
 
-namespace testing {
-class ChannelzRegistryPeer;
-}
-
 // singleton registry object to track all objects that are needed to support
 // channelz bookkeeping. All objects share globally distributed uuids.
 class ChannelzRegistry {
@@ -48,7 +45,9 @@ class ChannelzRegistry {
     return Default()->InternalRegister(node);
   }
   static void Unregister(intptr_t uuid) { Default()->InternalUnregister(uuid); }
-  static BaseNode* Get(intptr_t uuid) { return Default()->InternalGet(uuid); }
+  static RefCountedPtr<BaseNode> Get(intptr_t uuid) {
+    return Default()->InternalGet(uuid);
+  }
 
   // Returns the allocated JSON string that represents the proto
   // GetTopChannelsResponse as per channelz.proto.
@@ -67,13 +66,6 @@ class ChannelzRegistry {
   static void LogAllEntities() { Default()->InternalLogAllEntities(); }
 
  private:
-  GPRC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW
-  GPRC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
-  friend class testing::ChannelzRegistryPeer;
-
-  ChannelzRegistry();
-  ~ChannelzRegistry();
-
   // Returned the singleton instance of ChannelzRegistry;
   static ChannelzRegistry* Default();
 
@@ -86,27 +78,17 @@ class ChannelzRegistry {
 
   // if object with uuid has previously been registered as the correct type,
   // returns the void* associated with that uuid. Else returns nullptr.
-  BaseNode* InternalGet(intptr_t uuid);
+  RefCountedPtr<BaseNode> InternalGet(intptr_t uuid);
 
   char* InternalGetTopChannels(intptr_t start_channel_id);
   char* InternalGetServers(intptr_t start_server_id);
 
-  // If entities_ has over a certain threshold of empty slots, it will
-  // compact the vector and move all used slots to the front.
-  void MaybePerformCompactionLocked();
-
-  // Performs binary search on entities_ to find the index with that uuid.
-  // If direct_hit_needed, then will return -1 in case of absence.
-  // Else, will return idx of the first uuid higher than the target.
-  int FindByUuidLocked(intptr_t uuid, bool direct_hit_needed);
-
   void InternalLogAllEntities();
 
   // protects members
-  gpr_mu mu_;
-  InlinedVector<BaseNode*, 20> entities_;
+  Mutex mu_;
+  Map<intptr_t, BaseNode*> node_map_;
   intptr_t uuid_generator_ = 0;
-  int num_empty_slots_ = 0;
 };
 
 }  // namespace channelz