grpc 1.14.2 → 1.15.0.pre1

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

@@ -35,6 +35,10 @@
 #define GRPC_ARG_CHANNELZ_CHANNEL_NODE_CREATION_FUNC \
   "grpc.channelz_channel_node_creation_func"
 
+// 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"
+
 namespace grpc_core {
 namespace channelz {
 
@@ -45,7 +49,8 @@ class ChannelNodePeer;
 class ChannelNode : public RefCounted<ChannelNode> {
  public:
   static RefCountedPtr<ChannelNode> MakeChannelNode(
-      grpc_channel* channel, size_t channel_tracer_max_nodes);
+      grpc_channel* channel, size_t channel_tracer_max_nodes,
+      bool is_top_level_channel);
 
   void RecordCallStarted();
   void RecordCallFailed() {
@@ -55,7 +60,8 @@ class ChannelNode : public RefCounted<ChannelNode> {
     gpr_atm_no_barrier_fetch_add(&calls_succeeded_, (gpr_atm(1)));
   }
 
-  char* RenderJSON();
+  grpc_json* RenderJson();
+  char* RenderJsonString();
 
   // helper for getting and populating connectivity state. It is virtual
   // because it allows the client_channel specific code to live in ext/
@@ -74,11 +80,13 @@ class ChannelNode : public RefCounted<ChannelNode> {
   bool ChannelIsDestroyed() { return channel_ == nullptr; }
 
   intptr_t channel_uuid() { return channel_uuid_; }
+  bool is_top_level_channel() { return is_top_level_channel_; }
 
  protected:
   GPRC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
   GPRC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW
-  ChannelNode(grpc_channel* channel, size_t channel_tracer_max_nodes);
+  ChannelNode(grpc_channel* channel, size_t channel_tracer_max_nodes,
+              bool is_top_level_channel);
   virtual ~ChannelNode();
 
  private:
@@ -92,6 +100,7 @@ class ChannelNode : public RefCounted<ChannelNode> {
   gpr_atm calls_failed_ = 0;
   gpr_atm last_call_started_millis_ = 0;
   intptr_t channel_uuid_;
+  bool is_top_level_channel_ = true;
   ManualConstructor<ChannelTrace> trace_;
 };
 
@@ -116,7 +125,7 @@ class SubchannelNode : public RefCounted<SubchannelNode> {
 // Creation functions
 
 typedef RefCountedPtr<ChannelNode> (*ChannelNodeCreationFunc)(grpc_channel*,
-                                                              size_t);
+                                                              size_t, bool);
 
 }  // namespace channelz
 }  // namespace grpc_core

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

@@ -19,16 +19,20 @@
 #include <grpc/impl/codegen/port_platform.h>
 
 #include "src/core/lib/channel/channel_trace.h"
+#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/channelz_registry.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/mutex_lock.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/sync.h>
 
 #include <cstring>
 
 namespace grpc_core {
+namespace channelz {
 namespace {
 
 // singleton instance of the registry.
@@ -49,12 +53,93 @@ ChannelzRegistry::ChannelzRegistry() { gpr_mu_init(&mu_); }
 
 ChannelzRegistry::~ChannelzRegistry() { gpr_mu_destroy(&mu_); }
 
-void ChannelzRegistry::InternalUnregister(intptr_t uuid) {
+intptr_t ChannelzRegistry::InternalRegisterEntry(const RegistryEntry& entry) {
+  MutexLock lock(&mu_);
+  entities_.push_back(entry);
+  intptr_t uuid = entities_.size();
+  return uuid;
+}
+
+void ChannelzRegistry::InternalUnregisterEntry(intptr_t uuid, EntityType type) {
   GPR_ASSERT(uuid >= 1);
-  gpr_mu_lock(&mu_);
+  MutexLock lock(&mu_);
   GPR_ASSERT(static_cast<size_t>(uuid) <= entities_.size());
-  entities_[uuid - 1] = nullptr;
-  gpr_mu_unlock(&mu_);
+  GPR_ASSERT(entities_[uuid - 1].type == type);
+  entities_[uuid - 1].object = nullptr;
+  entities_[uuid - 1].type = EntityType::kUnset;
+}
+
+void* ChannelzRegistry::InternalGetEntry(intptr_t uuid, EntityType type) {
+  MutexLock lock(&mu_);
+  if (uuid < 1 || uuid > static_cast<intptr_t>(entities_.size())) {
+    return nullptr;
+  }
+  if (entities_[uuid - 1].type == type) {
+    return entities_[uuid - 1].object;
+  } else {
+    return nullptr;
+  }
+}
+
+char* ChannelzRegistry::InternalGetTopChannels(intptr_t start_channel_id) {
+  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
+  grpc_json* json = top_level_json;
+  grpc_json* json_iterator = nullptr;
+  InlinedVector<ChannelNode*, 10> top_level_channels;
+  // uuids index into entities one-off (idx 0 is really uuid 1, since 0 is
+  // reserved). However, we want to support requests coming in with
+  // start_channel_id=0, which signifies "give me everything." Hence this
+  // funky looking line below.
+  size_t start_idx = start_channel_id == 0 ? 0 : start_channel_id - 1;
+  for (size_t i = start_idx; i < entities_.size(); ++i) {
+    if (entities_[i].type == EntityType::kChannelNode) {
+      ChannelNode* channel_node =
+          static_cast<ChannelNode*>(entities_[i].object);
+      if (channel_node->is_top_level_channel()) {
+        top_level_channels.push_back(channel_node);
+      }
+    }
+  }
+  if (top_level_channels.size() > 0) {
+    // create list of channels
+    grpc_json* array_parent = grpc_json_create_child(
+        nullptr, json, "channel", nullptr, GRPC_JSON_ARRAY, false);
+    for (size_t i = 0; i < top_level_channels.size(); ++i) {
+      grpc_json* channel_json = top_level_channels[i]->RenderJson();
+      json_iterator =
+          grpc_json_link_child(array_parent, channel_json, json_iterator);
+    }
+  }
+  // For now we do not have any pagination rules. In the future we could
+  // pick a constant for max_channels_sent for a GetTopChannels request.
+  // Tracking: https://github.com/grpc/grpc/issues/16019.
+  json_iterator = grpc_json_create_child(nullptr, json, "end", nullptr,
+                                         GRPC_JSON_TRUE, false);
+  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
+  grpc_json_destroy(top_level_json);
+  return json_str;
 }
 
+}  // namespace channelz
 }  // namespace grpc_core
+
+char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
+  return grpc_core::channelz::ChannelzRegistry::GetTopChannels(
+      start_channel_id);
+}
+
+char* grpc_channelz_get_channel(intptr_t channel_id) {
+  grpc_core::channelz::ChannelNode* channel_node =
+      grpc_core::channelz::ChannelzRegistry::GetChannelNode(channel_id);
+  if (channel_node == nullptr) {
+    return nullptr;
+  }
+  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
+  grpc_json* json = top_level_json;
+  grpc_json* channel_json = channel_node->RenderJson();
+  channel_json->key = "channel";
+  grpc_json_link_child(json, channel_json, nullptr);
+  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
+  grpc_json_destroy(top_level_json);
+  return json_str;
+}

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

@@ -22,11 +22,13 @@
 #include <grpc/impl/codegen/port_platform.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>
 
 namespace grpc_core {
+namespace channelz {
 
 // singleton registry object to track all objects that are needed to support
 // channelz bookkeeping. All objects share globally distributed uuids.
@@ -35,26 +37,56 @@ class ChannelzRegistry {
   // To be called in grpc_init()
   static void Init();
 
-  // To be callen in grpc_shutdown();
+  // To be called in grpc_shutdown();
   static void Shutdown();
 
-  // globally registers a channelz Object. Returns its unique uuid
-  template <typename Object>
-  static intptr_t Register(Object* object) {
-    return Default()->InternalRegister(object);
+  // Register/Unregister/Get for ChannelNode
+  static intptr_t RegisterChannelNode(ChannelNode* channel_node) {
+    RegistryEntry entry(channel_node, EntityType::kChannelNode);
+    return Default()->InternalRegisterEntry(entry);
+  }
+  static void UnregisterChannelNode(intptr_t uuid) {
+    Default()->InternalUnregisterEntry(uuid, EntityType::kChannelNode);
+  }
+  static ChannelNode* GetChannelNode(intptr_t uuid) {
+    void* gotten = Default()->InternalGetEntry(uuid, EntityType::kChannelNode);
+    return gotten == nullptr ? nullptr : static_cast<ChannelNode*>(gotten);
   }
 
-  // globally unregisters the object that is associated to uuid.
-  static void Unregister(intptr_t uuid) { Default()->InternalUnregister(uuid); }
+  // Register/Unregister/Get for SubchannelNode
+  static intptr_t RegisterSubchannelNode(SubchannelNode* channel_node) {
+    RegistryEntry entry(channel_node, EntityType::kSubchannelNode);
+    return Default()->InternalRegisterEntry(entry);
+  }
+  static void UnregisterSubchannelNode(intptr_t uuid) {
+    Default()->InternalUnregisterEntry(uuid, EntityType::kSubchannelNode);
+  }
+  static SubchannelNode* GetSubchannelNode(intptr_t uuid) {
+    void* gotten =
+        Default()->InternalGetEntry(uuid, EntityType::kSubchannelNode);
+    return gotten == nullptr ? nullptr : static_cast<SubchannelNode*>(gotten);
+  }
 
-  // if object with uuid has previously been registered, returns the
-  // Object associated with that uuid. Else returns nullptr.
-  template <typename Object>
-  static Object* Get(intptr_t uuid) {
-    return Default()->InternalGet<Object>(uuid);
+  // Returns the allocated JSON string that represents the proto
+  // GetTopChannelsResponse as per channelz.proto.
+  static char* GetTopChannels(intptr_t start_channel_id) {
+    return Default()->InternalGetTopChannels(start_channel_id);
   }
 
  private:
+  enum class EntityType {
+    kChannelNode,
+    kSubchannelNode,
+    kUnset,
+  };
+
+  struct RegistryEntry {
+    RegistryEntry(void* object_in, EntityType type_in)
+        : object(object_in), type(type_in) {}
+    void* object;
+    EntityType type;
+  };
+
   GPRC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW
   GPRC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
 
@@ -64,40 +96,25 @@ class ChannelzRegistry {
   // Returned the singleton instance of ChannelzRegistry;
   static ChannelzRegistry* Default();
 
-  // globally registers a channelz Object. Returns its unique uuid
-  template <typename Object>
-  intptr_t InternalRegister(Object* object) {
-    gpr_mu_lock(&mu_);
-    entities_.push_back(static_cast<void*>(object));
-    intptr_t uuid = entities_.size();
-    gpr_mu_unlock(&mu_);
-    return uuid;
-  }
+  // globally registers an Entry. Returns its unique uuid
+  intptr_t InternalRegisterEntry(const RegistryEntry& entry);
 
-  // globally unregisters the object that is associated to uuid.
-  void InternalUnregister(intptr_t uuid);
-
-  // if object with uuid has previously been registered, returns the
-  // Object associated with that uuid. Else returns nullptr.
-  template <typename Object>
-  Object* InternalGet(intptr_t uuid) {
-    gpr_mu_lock(&mu_);
-    if (uuid < 1 || uuid > static_cast<intptr_t>(entities_.size())) {
-      gpr_mu_unlock(&mu_);
-      return nullptr;
-    }
-    Object* ret = static_cast<Object*>(entities_[uuid - 1]);
-    gpr_mu_unlock(&mu_);
-    return ret;
-  }
+  // globally unregisters the object that is associated to uuid. Also does
+  // sanity check that an object doesn't try to unregister the wrong type.
+  void InternalUnregisterEntry(intptr_t uuid, EntityType type);
+
+  // if object with uuid has previously been registered as the correct type,
+  // returns the void* associated with that uuid. Else returns nullptr.
+  void* InternalGetEntry(intptr_t uuid, EntityType type);
 
-  // private members
+  char* InternalGetTopChannels(intptr_t start_channel_id);
 
   // protects entities_ and uuid_
   gpr_mu mu_;
-  InlinedVector<void*, 20> entities_;
+  InlinedVector<RegistryEntry, 20> entities_;
 };
 
+}  // namespace channelz
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H */

data/src/core/lib/gpr/arena.cc

@@ -25,6 +25,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
+#include <grpc/support/sync.h>
 
 #include "src/core/lib/gpr/alloc.h"
 
@@ -36,8 +37,6 @@
 
 #ifdef SIMPLE_ARENA_FOR_DEBUGGING
 
-#include <grpc/support/sync.h>
-
 struct gpr_arena {
   gpr_mu mu;
   void** ptrs;
@@ -78,14 +77,17 @@ void* gpr_arena_alloc(gpr_arena* arena, size_t size) {
 // would allow us to use the alignment actually needed by the caller.
 
 typedef struct zone {
-  size_t size_begin;
-  size_t size_end;
-  gpr_atm next_atm;
+  zone* next;
 } zone;
 
 struct gpr_arena {
-  gpr_atm size_so_far;
+  // Keep track of the total used size. We use this in our call sizing
+  // historesis.
+  gpr_atm total_used;
+  size_t initial_zone_size;
   zone initial_zone;
+  zone* last_zone;
+  gpr_mu arena_growth_mutex;
 };
 
 static void* zalloc_aligned(size_t size) {
@@ -98,16 +100,19 @@ gpr_arena* gpr_arena_create(size_t initial_size) {
   initial_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(initial_size);
   gpr_arena* a = static_cast<gpr_arena*>(zalloc_aligned(
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena)) + initial_size));
-  a->initial_zone.size_end = initial_size;
+  a->initial_zone_size = initial_size;
+  a->last_zone = &a->initial_zone;
+  gpr_mu_init(&a->arena_growth_mutex);
   return a;
 }
 
 size_t gpr_arena_destroy(gpr_arena* arena) {
-  gpr_atm size = gpr_atm_no_barrier_load(&arena->size_so_far);
-  zone* z = (zone*)gpr_atm_no_barrier_load(&arena->initial_zone.next_atm);
+  gpr_mu_destroy(&arena->arena_growth_mutex);
+  gpr_atm size = gpr_atm_no_barrier_load(&arena->total_used);
+  zone* z = arena->initial_zone.next;
   gpr_free_aligned(arena);
   while (z) {
-    zone* next_z = (zone*)gpr_atm_no_barrier_load(&z->next_atm);
+    zone* next_z = z->next;
     gpr_free_aligned(z);
     z = next_z;
   }
@@ -116,37 +121,25 @@ size_t gpr_arena_destroy(gpr_arena* arena) {
 
 void* gpr_arena_alloc(gpr_arena* arena, size_t size) {
   size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(size);
-  size_t start = static_cast<size_t>(
-      gpr_atm_no_barrier_fetch_add(&arena->size_so_far, size));
-  zone* z = &arena->initial_zone;
-  while (start > z->size_end) {
-    zone* next_z = (zone*)gpr_atm_acq_load(&z->next_atm);
-    if (next_z == nullptr) {
-      size_t next_z_size =
-          static_cast<size_t>(gpr_atm_no_barrier_load(&arena->size_so_far));
-      next_z = static_cast<zone*>(zalloc_aligned(
-          GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone)) + next_z_size));
-      next_z->size_begin = z->size_end;
-      next_z->size_end = z->size_end + next_z_size;
-      if (!gpr_atm_rel_cas(&z->next_atm, static_cast<gpr_atm>(NULL),
-                           (gpr_atm)next_z)) {
-        gpr_free_aligned(next_z);
-        next_z = (zone*)gpr_atm_acq_load(&z->next_atm);
-      }
-    }
-    z = next_z;
-  }
-  if (start + size > z->size_end) {
-    return gpr_arena_alloc(arena, size);
+  size_t begin = gpr_atm_no_barrier_fetch_add(&arena->total_used, size);
+  if (begin + size <= arena->initial_zone_size) {
+    return reinterpret_cast<char*>(arena) +
+           GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena)) + begin;
+  } else {
+    // If the allocation isn't able to end in the initial zone, create a new
+    // zone for this allocation, and any unused space in the initial zone is
+    // wasted. This overflowing and wasting is uncommon because of our arena
+    // sizing historesis (that is, most calls should have a large enough initial
+    // zone and will not need to grow the arena).
+    gpr_mu_lock(&arena->arena_growth_mutex);
+    zone* z = static_cast<zone*>(
+        zalloc_aligned(GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone)) + size));
+    arena->last_zone->next = z;
+    arena->last_zone = z;
+    gpr_mu_unlock(&arena->arena_growth_mutex);
+    return reinterpret_cast<char*>(z) +
+           GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone));
   }
-  GPR_ASSERT(start >= z->size_begin);
-  GPR_ASSERT(start + size <= z->size_end);
-  char* ptr = (z == &arena->initial_zone)
-                  ? reinterpret_cast<char*>(arena) +
-                        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena))
-                  : reinterpret_cast<char*>(z) +
-                        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone));
-  return ptr + start - z->size_begin;
 }
 
 #endif  // SIMPLE_ARENA_FOR_DEBUGGING

data/src/core/lib/gprpp/fork.cc

@@ -157,11 +157,11 @@ class ThreadState {
 }  // namespace
 
 void Fork::GlobalInit() {
-  if (!overrideEnabled_) {
+  if (!override_enabled_) {
 #ifdef GRPC_ENABLE_FORK_SUPPORT
-    supportEnabled_ = true;
+    support_enabled_ = true;
 #else
-    supportEnabled_ = false;
+    support_enabled_ = false;
 #endif
     bool env_var_set = false;
     char* env = gpr_getenv("GRPC_ENABLE_FORK_SUPPORT");
@@ -172,7 +172,7 @@ void Fork::GlobalInit() {
                                      "False", "FALSE", "0"};
       for (size_t i = 0; i < GPR_ARRAY_SIZE(truthy); i++) {
         if (0 == strcmp(env, truthy[i])) {
-          supportEnabled_ = true;
+          support_enabled_ = true;
           env_var_set = true;
           break;
         }
@@ -180,7 +180,7 @@ void Fork::GlobalInit() {
       if (!env_var_set) {
         for (size_t i = 0; i < GPR_ARRAY_SIZE(falsey); i++) {
           if (0 == strcmp(env, falsey[i])) {
-            supportEnabled_ = false;
+            support_enabled_ = false;
             env_var_set = true;
             break;
           }
@@ -189,72 +189,80 @@ void Fork::GlobalInit() {
       gpr_free(env);
     }
   }
-  if (supportEnabled_) {
-    execCtxState_ = grpc_core::New<internal::ExecCtxState>();
-    threadState_ = grpc_core::New<internal::ThreadState>();
+  if (support_enabled_) {
+    exec_ctx_state_ = grpc_core::New<internal::ExecCtxState>();
+    thread_state_ = grpc_core::New<internal::ThreadState>();
   }
 }
 
 void Fork::GlobalShutdown() {
-  if (supportEnabled_) {
-    grpc_core::Delete(execCtxState_);
-    grpc_core::Delete(threadState_);
+  if (support_enabled_) {
+    grpc_core::Delete(exec_ctx_state_);
+    grpc_core::Delete(thread_state_);
   }
 }
 
-bool Fork::Enabled() { return supportEnabled_; }
+bool Fork::Enabled() { return support_enabled_; }
 
 // Testing Only
 void Fork::Enable(bool enable) {
-  overrideEnabled_ = true;
-  supportEnabled_ = enable;
+  override_enabled_ = true;
+  support_enabled_ = enable;
 }
 
 void Fork::IncExecCtxCount() {
-  if (supportEnabled_) {
-    execCtxState_->IncExecCtxCount();
+  if (support_enabled_) {
+    exec_ctx_state_->IncExecCtxCount();
   }
 }
 
 void Fork::DecExecCtxCount() {
-  if (supportEnabled_) {
-    execCtxState_->DecExecCtxCount();
+  if (support_enabled_) {
+    exec_ctx_state_->DecExecCtxCount();
   }
 }
 
+void Fork::SetResetChildPollingEngineFunc(
+    Fork::child_postfork_func reset_child_polling_engine) {
+  reset_child_polling_engine_ = reset_child_polling_engine;
+}
+Fork::child_postfork_func Fork::GetResetChildPollingEngineFunc() {
+  return reset_child_polling_engine_;
+}
+
 bool Fork::BlockExecCtx() {
-  if (supportEnabled_) {
-    return execCtxState_->BlockExecCtx();
+  if (support_enabled_) {
+    return exec_ctx_state_->BlockExecCtx();
   }
   return false;
 }
 
 void Fork::AllowExecCtx() {
-  if (supportEnabled_) {
-    execCtxState_->AllowExecCtx();
+  if (support_enabled_) {
+    exec_ctx_state_->AllowExecCtx();
   }
 }
 
 void Fork::IncThreadCount() {
-  if (supportEnabled_) {
-    threadState_->IncThreadCount();
+  if (support_enabled_) {
+    thread_state_->IncThreadCount();
   }
 }
 
 void Fork::DecThreadCount() {
-  if (supportEnabled_) {
-    threadState_->DecThreadCount();
+  if (support_enabled_) {
+    thread_state_->DecThreadCount();
   }
 }
 void Fork::AwaitThreads() {
-  if (supportEnabled_) {
-    threadState_->AwaitThreads();
+  if (support_enabled_) {
+    thread_state_->AwaitThreads();
   }
 }
 
-internal::ExecCtxState* Fork::execCtxState_ = nullptr;
-internal::ThreadState* Fork::threadState_ = nullptr;
-bool Fork::supportEnabled_ = false;
-bool Fork::overrideEnabled_ = false;
-
+internal::ExecCtxState* Fork::exec_ctx_state_ = nullptr;
+internal::ThreadState* Fork::thread_state_ = nullptr;
+bool Fork::support_enabled_ = false;
+bool Fork::override_enabled_ = false;
+Fork::child_postfork_func Fork::reset_child_polling_engine_ = nullptr;
 }  // namespace grpc_core