grpc 1.55.0 → 1.56.0.pre3

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

@@ -22,12 +22,14 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cstdint>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/support/cpu.h>
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
@@ -37,7 +39,6 @@
 #include "src/core/lib/channel/channelz_registry.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/json/json_writer.h"
 #include "src/core/lib/transport/connectivity_state.h"
@@ -67,66 +68,87 @@ std::string BaseNode::RenderJsonString() {
 // CallCountingHelper
 //
 
-CallCountingHelper::CallCountingHelper() {
-  num_cores_ = std::max(1u, gpr_cpu_num_cores());
-  per_cpu_counter_data_storage_.reserve(num_cores_);
-  for (size_t i = 0; i < num_cores_; ++i) {
-    per_cpu_counter_data_storage_.emplace_back();
+void CallCountingHelper::RecordCallStarted() {
+  calls_started_.fetch_add(1, std::memory_order_relaxed);
+  last_call_started_cycle_.store(gpr_get_cycle_counter(),
+                                 std::memory_order_relaxed);
+}
+
+void CallCountingHelper::RecordCallFailed() {
+  calls_failed_.fetch_add(1, std::memory_order_relaxed);
+}
+
+void CallCountingHelper::RecordCallSucceeded() {
+  calls_succeeded_.fetch_add(1, std::memory_order_relaxed);
+}
+
+void CallCountingHelper::PopulateCallCounts(Json::Object* json) {
+  auto calls_started = calls_started_.load(std::memory_order_relaxed);
+  auto calls_succeeded = calls_succeeded_.load(std::memory_order_relaxed);
+  auto calls_failed = calls_failed_.load(std::memory_order_relaxed);
+  auto last_call_started_cycle =
+      last_call_started_cycle_.load(std::memory_order_relaxed);
+  if (calls_started != 0) {
+    (*json)["callsStarted"] = Json::FromString(absl::StrCat(calls_started));
+    gpr_timespec ts = gpr_convert_clock_type(
+        gpr_cycle_counter_to_time(last_call_started_cycle), GPR_CLOCK_REALTIME);
+    (*json)["lastCallStartedTimestamp"] =
+        Json::FromString(gpr_format_timespec(ts));
+  }
+  if (calls_succeeded != 0) {
+    (*json)["callsSucceeded"] = Json::FromString(absl::StrCat(calls_succeeded));
+  }
+  if (calls_failed != 0) {
+    (*json)["callsFailed"] = Json::FromString(absl::StrCat(calls_failed));
   }
 }
 
-void CallCountingHelper::RecordCallStarted() {
-  AtomicCounterData& data =
-      per_cpu_counter_data_storage_[ExecCtx::Get()->starting_cpu()];
+//
+// PerCpuCallCountingHelper
+//
+
+void PerCpuCallCountingHelper::RecordCallStarted() {
+  auto& data = per_cpu_data_.this_cpu();
   data.calls_started.fetch_add(1, std::memory_order_relaxed);
   data.last_call_started_cycle.store(gpr_get_cycle_counter(),
                                      std::memory_order_relaxed);
 }
 
-void CallCountingHelper::RecordCallFailed() {
-  per_cpu_counter_data_storage_[ExecCtx::Get()->starting_cpu()]
-      .calls_failed.fetch_add(1, std::memory_order_relaxed);
+void PerCpuCallCountingHelper::RecordCallFailed() {
+  per_cpu_data_.this_cpu().calls_failed.fetch_add(1, std::memory_order_relaxed);
 }
 
-void CallCountingHelper::RecordCallSucceeded() {
-  per_cpu_counter_data_storage_[ExecCtx::Get()->starting_cpu()]
-      .calls_succeeded.fetch_add(1, std::memory_order_relaxed);
-}
-
-void CallCountingHelper::CollectData(CounterData* out) {
-  for (size_t core = 0; core < num_cores_; ++core) {
-    AtomicCounterData& data = per_cpu_counter_data_storage_[core];
-
-    out->calls_started += data.calls_started.load(std::memory_order_relaxed);
-    out->calls_succeeded +=
-        per_cpu_counter_data_storage_[core].calls_succeeded.load(
-            std::memory_order_relaxed);
-    out->calls_failed += per_cpu_counter_data_storage_[core].calls_failed.load(
-        std::memory_order_relaxed);
-    const gpr_cycle_counter last_call =
-        per_cpu_counter_data_storage_[core].last_call_started_cycle.load(
-            std::memory_order_relaxed);
-    if (last_call > out->last_call_started_cycle) {
-      out->last_call_started_cycle = last_call;
-    }
-  }
+void PerCpuCallCountingHelper::RecordCallSucceeded() {
+  per_cpu_data_.this_cpu().calls_succeeded.fetch_add(1,
+                                                     std::memory_order_relaxed);
 }
 
-void CallCountingHelper::PopulateCallCounts(Json::Object* json) {
-  CounterData data;
-  CollectData(&data);
-  if (data.calls_started != 0) {
-    (*json)["callsStarted"] = std::to_string(data.calls_started);
+void PerCpuCallCountingHelper::PopulateCallCounts(Json::Object* json) {
+  int64_t calls_started = 0;
+  int64_t calls_succeeded = 0;
+  int64_t calls_failed = 0;
+  gpr_cycle_counter last_call_started_cycle = 0;
+  for (const auto& cpu : per_cpu_data_) {
+    calls_started += cpu.calls_started.load(std::memory_order_relaxed);
+    calls_succeeded += cpu.calls_succeeded.load(std::memory_order_relaxed);
+    calls_failed += cpu.calls_failed.load(std::memory_order_relaxed);
+    last_call_started_cycle =
+        std::max(last_call_started_cycle,
+                 cpu.last_call_started_cycle.load(std::memory_order_relaxed));
+  }
+
+  if (calls_started != 0) {
+    (*json)["callsStarted"] = Json::FromString(absl::StrCat(calls_started));
     gpr_timespec ts = gpr_convert_clock_type(
-        gpr_cycle_counter_to_time(data.last_call_started_cycle),
-        GPR_CLOCK_REALTIME);
-    (*json)["lastCallStartedTimestamp"] = gpr_format_timespec(ts);
+        gpr_cycle_counter_to_time(last_call_started_cycle), GPR_CLOCK_REALTIME);
+    (*json)["lastCallStartedTimestamp"] =
+        Json::FromString(gpr_format_timespec(ts));
   }
-  if (data.calls_succeeded != 0) {
-    (*json)["callsSucceeded"] = std::to_string(data.calls_succeeded);
+  if (calls_succeeded != 0) {
+    (*json)["callsSucceeded"] = Json::FromString(absl::StrCat(calls_succeeded));
   }
-  if (data.calls_failed) {
-    (*json)["callsFailed"] = std::to_string(data.calls_failed);
+  if (calls_failed != 0) {
+    (*json)["callsFailed"] = Json::FromString(absl::StrCat(calls_failed));
   }
 }
 
@@ -161,7 +183,7 @@ const char* ChannelNode::GetChannelConnectivityStateChangeString(
 
 Json ChannelNode::RenderJson() {
   Json::Object data = {
-      {"target", target_},
+      {"target", Json::FromString(target_)},
   };
   // Connectivity state.
   // If low-order bit is on, then the field is set.
@@ -169,9 +191,9 @@ Json ChannelNode::RenderJson() {
   if ((state_field & 1) != 0) {
     grpc_connectivity_state state =
         static_cast<grpc_connectivity_state>(state_field >> 1);
-    data["state"] = Json::Object{
-        {"state", ConnectivityStateName(state)},
-    };
+    data["state"] = Json::FromObject({
+        {"state", Json::FromString(ConnectivityStateName(state))},
+    });
   }
   // Fill in the channel trace if applicable.
   Json trace_json = trace_.RenderJson();
@@ -182,16 +204,15 @@ Json ChannelNode::RenderJson() {
   call_counter_.PopulateCallCounts(&data);
   // Construct outer object.
   Json::Object json = {
-      {"ref",
-       Json::Object{
-           {"channelId", std::to_string(uuid())},
-       }},
-      {"data", std::move(data)},
+      {"ref", Json::FromObject({
+                  {"channelId", Json::FromString(absl::StrCat(uuid()))},
+              })},
+      {"data", Json::FromObject(std::move(data))},
   };
   // Template method. Child classes may override this to add their specific
   // functionality.
   PopulateChildRefs(&json);
-  return json;
+  return Json::FromObject(std::move(json));
 }
 
 void ChannelNode::PopulateChildRefs(Json::Object* json) {
@@ -199,20 +220,20 @@ void ChannelNode::PopulateChildRefs(Json::Object* json) {
   if (!child_subchannels_.empty()) {
     Json::Array array;
     for (intptr_t subchannel_uuid : child_subchannels_) {
-      array.emplace_back(Json::Object{
-          {"subchannelId", std::to_string(subchannel_uuid)},
-      });
+      array.emplace_back(Json::FromObject({
+          {"subchannelId", Json::FromString(absl::StrCat(subchannel_uuid))},
+      }));
     }
-    (*json)["subchannelRef"] = std::move(array);
+    (*json)["subchannelRef"] = Json::FromArray(std::move(array));
   }
   if (!child_channels_.empty()) {
     Json::Array array;
     for (intptr_t channel_uuid : child_channels_) {
-      array.emplace_back(Json::Object{
-          {"channelId", std::to_string(channel_uuid)},
-      });
+      array.emplace_back(Json::FromObject({
+          {"channelId", Json::FromString(absl::StrCat(channel_uuid))},
+      }));
     }
-    (*json)["channelRef"] = std::move(array);
+    (*json)["channelRef"] = Json::FromArray(std::move(array));
   }
 }
 
@@ -286,16 +307,17 @@ std::string ServerNode::RenderServerSockets(intptr_t start_socket_id,
     auto it = child_sockets_.lower_bound(start_socket_id);
     for (; it != child_sockets_.end() && sockets_rendered < pagination_limit;
          ++it, ++sockets_rendered) {
-      array.emplace_back(Json::Object{
-          {"socketId", std::to_string(it->first)},
-          {"name", it->second->name()},
-      });
+      array.emplace_back(Json::FromObject({
+          {"socketId", Json::FromString(absl::StrCat(it->first))},
+          {"name", Json::FromString(it->second->name())},
+      }));
+    }
+    object["socketRef"] = Json::FromArray(std::move(array));
+    if (it == child_sockets_.end()) {
+      object["end"] = Json::FromBool(true);
     }
-    object["socketRef"] = std::move(array);
-    if (it == child_sockets_.end()) object["end"] = true;
   }
-  Json json = std::move(object);
-  return JsonDump(json);
+  return JsonDump(Json::FromObject(std::move(object)));
 }
 
 Json ServerNode::RenderJson() {
@@ -309,11 +331,10 @@ Json ServerNode::RenderJson() {
   call_counter_.PopulateCallCounts(&data);
   // Construct top-level object.
   Json::Object object = {
-      {"ref",
-       Json::Object{
-           {"serverId", std::to_string(uuid())},
-       }},
-      {"data", std::move(data)},
+      {"ref", Json::FromObject({
+                  {"serverId", Json::FromString(absl::StrCat(uuid()))},
+              })},
+      {"data", Json::FromObject(std::move(data))},
   };
   // Render listen sockets.
   {
@@ -321,15 +342,15 @@ Json ServerNode::RenderJson() {
     if (!child_listen_sockets_.empty()) {
       Json::Array array;
       for (const auto& it : child_listen_sockets_) {
-        array.emplace_back(Json::Object{
-            {"socketId", std::to_string(it.first)},
-            {"name", it.second->name()},
-        });
+        array.emplace_back(Json::FromObject({
+            {"socketId", Json::FromString(absl::StrCat(it.first))},
+            {"name", Json::FromString(it.second->name())},
+        }));
       }
-      object["listenSocket"] = std::move(array);
+      object["listenSocket"] = Json::FromArray(std::move(array));
     }
   }
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 //
@@ -339,17 +360,19 @@ Json ServerNode::RenderJson() {
 Json SocketNode::Security::Tls::RenderJson() {
   Json::Object data;
   if (type == NameType::kStandardName) {
-    data["standard_name"] = name;
+    data["standard_name"] = Json::FromString(name);
   } else if (type == NameType::kOtherName) {
-    data["other_name"] = name;
+    data["other_name"] = Json::FromString(name);
   }
   if (!local_certificate.empty()) {
-    data["local_certificate"] = absl::Base64Escape(local_certificate);
+    data["local_certificate"] =
+        Json::FromString(absl::Base64Escape(local_certificate));
   }
   if (!remote_certificate.empty()) {
-    data["remote_certificate"] = absl::Base64Escape(remote_certificate);
+    data["remote_certificate"] =
+        Json::FromString(absl::Base64Escape(remote_certificate));
   }
-  return data;
+  return Json::FromObject(std::move(data));
 }
 
 //
@@ -367,12 +390,12 @@ Json SocketNode::Security::RenderJson() {
       }
       break;
     case ModelType::kOther:
-      if (other) {
+      if (other.has_value()) {
         data["other"] = *other;
       }
       break;
   }
-  return data;
+  return Json::FromObject(std::move(data));
 }
 
 namespace {
@@ -424,32 +447,32 @@ void PopulateSocketAddressJson(Json::Object* json, const char* name,
       auto address = StringToSockaddr(absl::StripPrefix(uri->path(), "/"));
       if (address.ok()) {
         std::string packed_host = grpc_sockaddr_get_packed_host(&*address);
-        (*json)[name] = Json::Object{
+        (*json)[name] = Json::FromObject({
             {"tcpip_address",
-             Json::Object{
-                 {"port", grpc_sockaddr_get_port(&*address)},
-                 {"ip_address", absl::Base64Escape(packed_host)},
-             }},
-        };
+             Json::FromObject({
+                 {"port", Json::FromString(
+                              absl::StrCat(grpc_sockaddr_get_port(&*address)))},
+                 {"ip_address",
+                  Json::FromString(absl::Base64Escape(packed_host))},
+             })},
+        });
         return;
       }
     } else if (uri->scheme() == "unix") {
-      (*json)[name] = Json::Object{
-          {"uds_address",
-           Json::Object{
-               {"filename", uri->path()},
-           }},
-      };
+      (*json)[name] = Json::FromObject({
+          {"uds_address", Json::FromObject({
+                              {"filename", Json::FromString(uri->path())},
+                          })},
+      });
       return;
     }
   }
   // Unknown address type.
-  (*json)[name] = Json::Object{
-      {"other_address",
-       Json::Object{
-           {"name", addr_str},
-       }},
-  };
+  (*json)[name] = Json::FromObject({
+      {"other_address", Json::FromObject({
+                            {"name", Json::FromString(addr_str)},
+                        })},
+  });
 }
 
 }  // namespace
@@ -491,14 +514,15 @@ Json SocketNode::RenderJson() {
   gpr_timespec ts;
   int64_t streams_started = streams_started_.load(std::memory_order_relaxed);
   if (streams_started != 0) {
-    data["streamsStarted"] = std::to_string(streams_started);
+    data["streamsStarted"] = Json::FromString(absl::StrCat(streams_started));
     gpr_cycle_counter last_local_stream_created_cycle =
         last_local_stream_created_cycle_.load(std::memory_order_relaxed);
     if (last_local_stream_created_cycle != 0) {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_local_stream_created_cycle),
           GPR_CLOCK_REALTIME);
-      data["lastLocalStreamCreatedTimestamp"] = gpr_format_timespec(ts);
+      data["lastLocalStreamCreatedTimestamp"] =
+          Json::FromString(gpr_format_timespec(ts));
     }
     gpr_cycle_counter last_remote_stream_created_cycle =
         last_remote_stream_created_cycle_.load(std::memory_order_relaxed);
@@ -506,49 +530,53 @@ Json SocketNode::RenderJson() {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_remote_stream_created_cycle),
           GPR_CLOCK_REALTIME);
-      data["lastRemoteStreamCreatedTimestamp"] = gpr_format_timespec(ts);
+      data["lastRemoteStreamCreatedTimestamp"] =
+          Json::FromString(gpr_format_timespec(ts));
     }
   }
   int64_t streams_succeeded =
       streams_succeeded_.load(std::memory_order_relaxed);
   if (streams_succeeded != 0) {
-    data["streamsSucceeded"] = std::to_string(streams_succeeded);
+    data["streamsSucceeded"] =
+        Json::FromString(absl::StrCat(streams_succeeded));
   }
   int64_t streams_failed = streams_failed_.load(std::memory_order_relaxed);
   if (streams_failed != 0) {
-    data["streamsFailed"] = std::to_string(streams_failed);
+    data["streamsFailed"] = Json::FromString(absl::StrCat(streams_failed));
   }
   int64_t messages_sent = messages_sent_.load(std::memory_order_relaxed);
   if (messages_sent != 0) {
-    data["messagesSent"] = std::to_string(messages_sent);
+    data["messagesSent"] = Json::FromString(absl::StrCat(messages_sent));
     ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(
             last_message_sent_cycle_.load(std::memory_order_relaxed)),
         GPR_CLOCK_REALTIME);
-    data["lastMessageSentTimestamp"] = gpr_format_timespec(ts);
+    data["lastMessageSentTimestamp"] =
+        Json::FromString(gpr_format_timespec(ts));
   }
   int64_t messages_received =
       messages_received_.load(std::memory_order_relaxed);
   if (messages_received != 0) {
-    data["messagesReceived"] = std::to_string(messages_received);
+    data["messagesReceived"] =
+        Json::FromString(absl::StrCat(messages_received));
     ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(
             last_message_received_cycle_.load(std::memory_order_relaxed)),
         GPR_CLOCK_REALTIME);
-    data["lastMessageReceivedTimestamp"] = gpr_format_timespec(ts);
+    data["lastMessageReceivedTimestamp"] =
+        Json::FromString(gpr_format_timespec(ts));
   }
   int64_t keepalives_sent = keepalives_sent_.load(std::memory_order_relaxed);
   if (keepalives_sent != 0) {
-    data["keepAlivesSent"] = std::to_string(keepalives_sent);
+    data["keepAlivesSent"] = Json::FromString(absl::StrCat(keepalives_sent));
   }
   // Create and fill the parent object.
   Json::Object object = {
-      {"ref",
-       Json::Object{
-           {"socketId", std::to_string(uuid())},
-           {"name", name()},
-       }},
-      {"data", std::move(data)},
+      {"ref", Json::FromObject({
+                  {"socketId", Json::FromString(absl::StrCat(uuid()))},
+                  {"name", Json::FromString(name())},
+              })},
+      {"data", Json::FromObject(std::move(data))},
   };
   if (security_ != nullptr &&
       security_->type != SocketNode::Security::ModelType::kUnset) {
@@ -556,7 +584,7 @@ Json SocketNode::RenderJson() {
   }
   PopulateSocketAddressJson(&object, "remote", remote_.c_str());
   PopulateSocketAddressJson(&object, "local", local_.c_str());
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 //
@@ -569,14 +597,13 @@ ListenSocketNode::ListenSocketNode(std::string local_addr, std::string name)
 
 Json ListenSocketNode::RenderJson() {
   Json::Object object = {
-      {"ref",
-       Json::Object{
-           {"socketId", std::to_string(uuid())},
-           {"name", name()},
-       }},
+      {"ref", Json::FromObject({
+                  {"socketId", Json::FromString(absl::StrCat(uuid()))},
+                  {"name", Json::FromString(name())},
+              })},
   };
   PopulateSocketAddressJson(&object, "local", local_addr_.c_str());
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 }  // namespace channelz

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

@@ -29,7 +29,6 @@
 #include <set>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -41,6 +40,7 @@
 #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"
@@ -122,8 +122,6 @@ class BaseNode : public RefCounted<BaseNode> {
 //   - perform rendering of the above items
 class CallCountingHelper {
  public:
-  CallCountingHelper();
-
   void RecordCallStarted();
   void RecordCallFailed();
   void RecordCallSucceeded();
@@ -135,44 +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};
-    // 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;
+#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};
   };
-
-  // collects the sharded data into one CounterData struct.
-  void CollectData(CounterData* out);
-
-  std::vector<AtomicCounterData> per_cpu_counter_data_storage_;
-  size_t num_cores_ = 0;
+  struct PerCpuData : public PerCpuDataHeader {
+    uint8_t padding[GPR_CACHELINE_SIZE - sizeof(PerCpuDataHeader)];
+  };
+#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_;