grpc 1.47.0 → 1.57.0

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

@@ -1,23 +1,23 @@
-/*
- *
- * Copyright 2018 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_CHANNEL_CHANNELZ_H
-#define GRPC_CORE_LIB_CHANNEL_CHANNELZ_H
+//
+//
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_H
+#define GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_H
 
 #include <grpc/support/port_platform.h>
 
@@ -30,16 +30,17 @@
 #include <string>
 #include <utility>
 
-#include "absl/container/inlined_vector.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/connectivity_state.h>
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/connectivity_state.h>
 #include <grpc/slice.h>
 
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/per_cpu.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"
@@ -52,14 +53,14 @@
 #define GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL \
   "grpc.channelz_is_internal_channel"
 
-/** 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. */
+/// 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.
 #define GRPC_ENABLE_CHANNELZ_DEFAULT true
 
-/** This is the default value for the maximum amount of memory used by trace
- * events per channel trace node. If
- * GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE is set, it will override
- * this default value. */
+/// This is the default value for the maximum amount of memory used by trace
+/// events per channel trace node. If
+/// GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE is set, it will override
+/// this default value.
 #define GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT (1024 * 4)
 
 namespace grpc_core {
@@ -121,8 +122,6 @@ class BaseNode : public RefCounted<BaseNode> {
 //   - perform rendering of the above items
 class CallCountingHelper {
  public:
-  CallCountingHelper();
-
   void RecordCallStarted();
   void RecordCallFailed();
   void RecordCallSucceeded();
@@ -134,45 +133,53 @@ class CallCountingHelper {
   // testing peer friend.
   friend class testing::CallCountingHelperPeer;
 
-  // TODO(soheil): add a proper PerCPU helper and use it here.
-  struct AtomicCounterData {
-    // Define the ctors so that we can use this structure in InlinedVector.
-    AtomicCounterData() = default;
-    AtomicCounterData(const AtomicCounterData& that)
-        : calls_started(that.calls_started.load(std::memory_order_relaxed)),
-          calls_succeeded(that.calls_succeeded.load(std::memory_order_relaxed)),
-          calls_failed(that.calls_failed.load(std::memory_order_relaxed)),
-          last_call_started_cycle(
-              that.last_call_started_cycle.load(std::memory_order_relaxed)) {}
+  std::atomic<int64_t> calls_started_{0};
+  std::atomic<int64_t> calls_succeeded_{0};
+  std::atomic<int64_t> calls_failed_{0};
+  std::atomic<gpr_cycle_counter> last_call_started_cycle_{0};
+};
+
+class PerCpuCallCountingHelper {
+ public:
+  void RecordCallStarted();
+  void RecordCallFailed();
+  void RecordCallSucceeded();
+
+  // Common rendering of the call count data and last_call_started_timestamp.
+  void PopulateCallCounts(Json::Object* json);
+
+ private:
+  // testing peer friend.
+  friend class testing::CallCountingHelperPeer;
 
+  // We want to ensure that this per-cpu data structure lands on different
+  // cachelines per cpu.
+  // With C++17 we can do so explicitly with an `alignas` specifier.
+  // Prior versions we can at best approximate it by padding the structure.
+  // It'll probably work out ok, but it's not guaranteed across allocators.
+  // (in the bad case where this gets split across cachelines we'll just have
+  // two cpus fighting over the same cacheline with a slight performance
+  // degregation).
+  // TODO(ctiller): When we move to C++17 delete the duplicate definition.
+#if __cplusplus >= 201703L
+  struct alignas(GPR_CACHELINE_SIZE) PerCpuData {
+    std::atomic<int64_t> calls_started{0};
+    std::atomic<int64_t> calls_succeeded{0};
+    std::atomic<int64_t> calls_failed{0};
+    std::atomic<gpr_cycle_counter> last_call_started_cycle{0};
+  };
+#else
+  struct PerCpuDataHeader {
     std::atomic<int64_t> calls_started{0};
     std::atomic<int64_t> calls_succeeded{0};
     std::atomic<int64_t> calls_failed{0};
     std::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(std::atomic<intptr_t>) -
-                    sizeof(std::atomic<gpr_cycle_counter>)];
   };
-  // TODO(soheilhy,veblush): Revist this after abseil integration.
-  // This has a problem when using abseil inlined_vector because it
-  // carries an alignment attribute properly but our allocator doesn't
-  // respect this. To avoid UBSAN errors, this should be removed with
-  // abseil inlined_vector.
-  // GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
-
-  struct CounterData {
-    int64_t calls_started = 0;
-    int64_t calls_succeeded = 0;
-    int64_t calls_failed = 0;
-    gpr_cycle_counter last_call_started_cycle = 0;
+  struct PerCpuData : public PerCpuDataHeader {
+    uint8_t padding[GPR_CACHELINE_SIZE - sizeof(PerCpuDataHeader)];
   };
-
-  // collects the sharded data into one CounterData struct.
-  void CollectData(CounterData* out);
-
-  // Really zero-sized, but 0-sized arrays are illegal on MSVC.
-  absl::InlinedVector<AtomicCounterData, 1> per_cpu_counter_data_storage_;
-  size_t num_cores_ = 0;
+#endif
+  PerCpu<PerCpuData> per_cpu_data_{PerCpuOptions().SetCpusPerShard(4)};
 };
 
 // Handles channelz bookkeeping for channels
@@ -271,7 +278,7 @@ class ServerNode : public BaseNode {
   void RecordCallSucceeded() { call_counter_.RecordCallSucceeded(); }
 
  private:
-  CallCountingHelper call_counter_;
+  PerCpuCallCountingHelper call_counter_;
   ChannelTrace trace_;
   Mutex child_mu_;  // Guards child maps below.
   std::map<intptr_t, RefCountedPtr<SocketNode>> child_sockets_;
@@ -304,6 +311,14 @@ class SocketNode : public BaseNode {
 
     Json RenderJson();
 
+    static absl::string_view ChannelArgName() {
+      return GRPC_ARG_CHANNELZ_SECURITY;
+    }
+
+    static int ChannelArgsCompare(const Security* a, const Security* b) {
+      return QsortCompare(a, b);
+    }
+
     grpc_arg MakeChannelArg() const;
 
     static RefCountedPtr<Security> GetFromChannelArgs(
@@ -363,4 +378,4 @@ class ListenSocketNode : public BaseNode {
 }  // namespace channelz
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_CHANNEL_CHANNELZ_H */
+#endif  // GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2017 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -24,10 +24,10 @@
 #include <cstdint>
 #include <cstring>
 #include <utility>
-
-#include "absl/container/inlined_vector.h"
+#include <vector>
 
 #include <grpc/grpc.h>
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
@@ -35,6 +35,7 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_writer.h"
 
 namespace grpc_core {
 namespace channelz {
@@ -77,7 +78,7 @@ RefCountedPtr<BaseNode> ChannelzRegistry::InternalGet(intptr_t uuid) {
 
 std::string ChannelzRegistry::InternalGetTopChannels(
     intptr_t start_channel_id) {
-  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
+  std::vector<RefCountedPtr<BaseNode>> top_level_channels;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
@@ -108,15 +109,16 @@ std::string ChannelzRegistry::InternalGetTopChannels(
     for (size_t i = 0; i < top_level_channels.size(); ++i) {
       array.emplace_back(top_level_channels[i]->RenderJson());
     }
-    object["channel"] = std::move(array);
+    object["channel"] = Json::FromArray(std::move(array));
+  }
+  if (node_after_pagination_limit == nullptr) {
+    object["end"] = Json::FromBool(true);
   }
-  if (node_after_pagination_limit == nullptr) object["end"] = true;
-  Json json(std::move(object));
-  return json.Dump();
+  return JsonDump(Json::FromObject(std::move(object)));
 }
 
 std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
-  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
+  std::vector<RefCountedPtr<BaseNode>> servers;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
@@ -147,15 +149,16 @@ std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
     for (size_t i = 0; i < servers.size(); ++i) {
       array.emplace_back(servers[i]->RenderJson());
     }
-    object["server"] = std::move(array);
+    object["server"] = Json::FromArray(std::move(array));
+  }
+  if (node_after_pagination_limit == nullptr) {
+    object["end"] = Json::FromBool(true);
   }
-  if (node_after_pagination_limit == nullptr) object["end"] = true;
-  Json json(std::move(object));
-  return json.Dump();
+  return JsonDump(Json::FromObject(std::move(object)));
 }
 
 void ChannelzRegistry::InternalLogAllEntities() {
-  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
+  std::vector<RefCountedPtr<BaseNode>> nodes;
   {
     MutexLock lock(&mu_);
     for (auto& p : node_map_) {
@@ -200,10 +203,10 @@ char* grpc_channelz_get_server(intptr_t server_id) {
           grpc_core::channelz::BaseNode::EntityType::kServer) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
+  grpc_core::Json json = grpc_core::Json::FromObject({
       {"server", server_node->RenderJson()},
-  };
-  return gpr_strdup(json.Dump().c_str());
+  });
+  return gpr_strdup(grpc_core::JsonDump(json).c_str());
 }
 
 char* grpc_channelz_get_server_sockets(intptr_t server_id,
@@ -239,10 +242,10 @@ char* grpc_channelz_get_channel(intptr_t channel_id) {
            grpc_core::channelz::BaseNode::EntityType::kInternalChannel)) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
+  grpc_core::Json json = grpc_core::Json::FromObject({
       {"channel", channel_node->RenderJson()},
-  };
-  return gpr_strdup(json.Dump().c_str());
+  });
+  return gpr_strdup(grpc_core::JsonDump(json).c_str());
 }
 
 char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
@@ -255,10 +258,10 @@ char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
           grpc_core::channelz::BaseNode::EntityType::kSubchannel) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
+  grpc_core::Json json = grpc_core::Json::FromObject({
       {"subchannel", subchannel_node->RenderJson()},
-  };
-  return gpr_strdup(json.Dump().c_str());
+  });
+  return gpr_strdup(grpc_core::JsonDump(json).c_str());
 }
 
 char* grpc_channelz_get_socket(intptr_t socket_id) {
@@ -271,8 +274,8 @@ char* grpc_channelz_get_socket(intptr_t socket_id) {
           grpc_core::channelz::BaseNode::EntityType::kSocket) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
+  grpc_core::Json json = grpc_core::Json::FromObject({
       {"socket", socket_node->RenderJson()},
-  };
-  return gpr_strdup(json.Dump().c_str());
+  });
+  return gpr_strdup(grpc_core::JsonDump(json).c_str());
 }

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

@@ -1,23 +1,23 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H
-#define GRPC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H
+//
+//
+// Copyright 2017 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H
+#define GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -97,4 +97,4 @@ class ChannelzRegistry {
 }  // namespace channelz
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H */
+#endif  // GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H