grpc 1.47.0 → 1.49.0.pre1

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

@@ -27,7 +27,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/alloc.h"
-#include "src/core/lib/promise/poll.h"
 
 grpc_core::TraceFlag grpc_trace_channel(false, "channel");
 grpc_core::TraceFlag grpc_trace_channel_stack(false, "channel_stack");
@@ -143,8 +142,8 @@ grpc_error_handle grpc_channel_stack_init(
     elems[i].channel_data = user_data;
     grpc_error_handle error =
         elems[i].filter->init_channel_elem(&elems[i], &args);
-    if (error != GRPC_ERROR_NONE) {
-      if (first_error == GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
+      if (GRPC_ERROR_IS_NONE(first_error)) {
         first_error = error;
       } else {
         GRPC_ERROR_UNREF(error);
@@ -205,8 +204,8 @@ grpc_error_handle grpc_call_stack_init(
   for (size_t i = 0; i < count; i++) {
     grpc_error_handle error =
         call_elems[i].filter->init_call_elem(&call_elems[i], elem_args);
-    if (error != GRPC_ERROR_NONE) {
-      if (first_error == GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
+      if (GRPC_ERROR_IS_NONE(first_error)) {
         first_error = error;
       } else {
         GRPC_ERROR_UNREF(error);

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

@@ -56,6 +56,7 @@
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/time_precise.h"
@@ -70,17 +71,6 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/transport.h"
 
-struct grpc_call_element;
-struct grpc_call_stack;
-struct grpc_channel_element;
-struct grpc_channel_stack;
-
-typedef struct grpc_channel_element grpc_channel_element;
-typedef struct grpc_call_element grpc_call_element;
-
-typedef struct grpc_channel_stack grpc_channel_stack;
-typedef struct grpc_call_stack grpc_call_stack;
-
 struct grpc_channel_element_args {
   grpc_channel_stack* channel_stack;
   const grpc_channel_args* channel_args;

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

@@ -21,7 +21,6 @@
 #include "src/core/lib/channel/channel_stack_builder.h"
 
 #include <algorithm>
-#include <utility>
 
 #include "src/core/lib/channel/channel_args.h"
 
@@ -38,8 +37,9 @@ ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   return *this;
 }
 
-ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(ChannelArgs args) {
-  args_ = std::move(args);
+ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(
+    const ChannelArgs& args) {
+  args_ = args;
   return *this;
 }
 

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

@@ -26,13 +26,10 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-
-typedef struct grpc_channel_stack grpc_channel_stack;
-typedef struct grpc_channel_element grpc_channel_element;
-typedef struct grpc_channel_filter grpc_channel_filter;
-typedef struct grpc_transport grpc_transport;
+#include "src/core/lib/transport/transport_fwd.h"
 
 namespace grpc_core {
 
@@ -65,8 +62,8 @@ class ChannelStackBuilder {
   // Query the transport.
   grpc_transport* transport() const { return transport_; }
 
-  // Set channel args (takes a copy of them).
-  ChannelStackBuilder& SetChannelArgs(ChannelArgs args);
+  // Set channel args.
+  ChannelStackBuilder& SetChannelArgs(const ChannelArgs& args);
 
   // Query the channel args.
   const ChannelArgs& channel_args() const { return args_; }

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

@@ -65,7 +65,6 @@ ChannelStackBuilderImpl::Build() {
   }
 
   // and initialize it
-  const grpc_channel_args* c_args = final_args.ToC();
   grpc_error_handle error = grpc_channel_stack_init(
       1,
       [](void* p, grpc_error_handle) {
@@ -73,11 +72,10 @@ ChannelStackBuilderImpl::Build() {
         grpc_channel_stack_destroy(stk);
         gpr_free(stk);
       },
-      channel_stack, stack->data(), stack->size(), c_args, name(),
-      channel_stack);
-  grpc_channel_args_destroy(c_args);
+      channel_stack, stack->data(), stack->size(), final_args.ToC().get(),
+      name(), channel_stack);
 
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_channel_stack_destroy(channel_stack);
     gpr_free(channel_stack);
     auto status = grpc_error_to_absl_status(error);

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

@@ -19,6 +19,7 @@
 
 #include "absl/status/statusor.h"
 
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 

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

@@ -20,11 +20,9 @@
 
 #include "src/core/lib/channel/channelz.h"
 
-#include <stdlib.h>
-
 #include <algorithm>
 #include <atomic>
-#include <type_traits>
+#include <memory>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
@@ -41,10 +39,7 @@
 #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/gprpp/host_port.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/uri/uri_parser.h"
 
@@ -423,42 +418,38 @@ namespace {
 void PopulateSocketAddressJson(Json::Object* json, const char* name,
                                const char* addr_str) {
   if (addr_str == nullptr) return;
-  Json::Object data;
   absl::StatusOr<URI> uri = URI::Parse(addr_str);
-  if (uri.ok() && (uri->scheme() == "ipv4" || uri->scheme() == "ipv6")) {
-    std::string host;
-    std::string port;
-    GPR_ASSERT(
-        SplitHostPort(absl::StripPrefix(uri->path(), "/"), &host, &port));
-    int port_num = -1;
-    if (!port.empty()) {
-      port_num = atoi(port.data());
-    }
-    grpc_resolved_address resolved_host;
-    grpc_error_handle error =
-        grpc_string_to_sockaddr(&resolved_host, host.c_str(), port_num);
-    if (error == GRPC_ERROR_NONE) {
-      std::string packed_host = grpc_sockaddr_get_packed_host(&resolved_host);
-      std::string b64_host = absl::Base64Escape(packed_host);
-      data["tcpip_address"] = Json::Object{
-          {"port", port_num},
-          {"ip_address", b64_host},
+  if (uri.ok()) {
+    if (uri->scheme() == "ipv4" || uri->scheme() == "ipv6") {
+      auto address = StringToSockaddr(absl::StripPrefix(uri->path(), "/"));
+      if (address.ok()) {
+        std::string packed_host = grpc_sockaddr_get_packed_host(&*address);
+        (*json)[name] = Json::Object{
+            {"tcpip_address",
+             Json::Object{
+                 {"port", grpc_sockaddr_get_port(&*address)},
+                 {"ip_address", absl::Base64Escape(packed_host)},
+             }},
+        };
+        return;
+      }
+    } else if (uri->scheme() == "unix") {
+      (*json)[name] = Json::Object{
+          {"uds_address",
+           Json::Object{
+               {"filename", uri->path()},
+           }},
       };
-      (*json)[name] = std::move(data);
       return;
     }
-    GRPC_ERROR_UNREF(error);
-  }
-  if (uri.ok() && uri->scheme() == "unix") {
-    data["uds_address"] = Json::Object{
-        {"filename", uri->path()},
-    };
-  } else {
-    data["other_address"] = Json::Object{
-        {"name", addr_str},
-    };
   }
-  (*json)[name] = std::move(data);
+  // Unknown address type.
+  (*json)[name] = Json::Object{
+      {"other_address",
+       Json::Object{
+           {"name", addr_str},
+       }},
+  };
 }
 
 }  // namespace

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

@@ -29,8 +29,8 @@
 #include <set>
 #include <string>
 #include <utility>
+#include <vector>
 
-#include "absl/container/inlined_vector.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -40,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/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -170,8 +171,7 @@ class CallCountingHelper {
   // 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_;
+  std::vector<AtomicCounterData> per_cpu_counter_data_storage_;
   size_t num_cores_ = 0;
 };
 
@@ -304,6 +304,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(

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

@@ -24,8 +24,7 @@
 #include <cstdint>
 #include <cstring>
 #include <utility>
-
-#include "absl/container/inlined_vector.h"
+#include <vector>
 
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
@@ -77,7 +76,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_);
@@ -116,7 +115,7 @@ std::string ChannelzRegistry::InternalGetTopChannels(
 }
 
 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_);
@@ -155,7 +154,7 @@ std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
 }
 
 void ChannelzRegistry::InternalLogAllEntities() {
-  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
+  std::vector<RefCountedPtr<BaseNode>> nodes;
   {
     MutexLock lock(&mu_);
     for (auto& p : node_map_) {

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

@@ -32,6 +32,7 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/lib/transport/transport_fwd.h"
 
 #define MAX_BUFFER_LENGTH 8192
 

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

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/transport/transport.h"

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

@@ -587,11 +587,17 @@ void ClientCallData::StartBatch(grpc_transport_stream_op_batch* b) {
       recv_trailing_state_ = RecvTrailingState::kForwarded;
       HookRecvTrailingMetadata(batch);
     }
-  } else if (cancelled_error_ != GRPC_ERROR_NONE) {
+  } else if (!GRPC_ERROR_IS_NONE(cancelled_error_)) {
     batch.CancelWith(GRPC_ERROR_REF(cancelled_error_), &flusher);
   }
 
-  if (batch.is_captured()) batch.ResumeWith(&flusher);
+  if (batch.is_captured()) {
+    if (!is_last()) {
+      batch.ResumeWith(&flusher);
+    } else {
+      batch.CancelWith(GRPC_ERROR_CANCELLED, &flusher);
+    }
+  }
 }
 
 // Handle cancellation.
@@ -692,7 +698,7 @@ void ClientCallData::RecvInitialMetadataReady(grpc_error_handle error) {
       abort();  // unreachable
   }
   Flusher flusher(this);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     recv_initial_metadata_->state = RecvInitialMetadata::kResponded;
     flusher.AddClosure(
         absl::exchange(recv_initial_metadata_->original_on_ready, nullptr),
@@ -829,7 +835,7 @@ void ClientCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
   }
   // If there was an error, we'll put that into the trailing metadata and
   // proceed as if there was not.
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     SetStatusFromError(recv_trailing_metadata_, error);
   }
   // Record that we've got the callback.
@@ -1149,7 +1155,7 @@ void ServerCallData::RecvInitialMetadataReady(grpc_error_handle error) {
   Flusher flusher(this);
   GPR_ASSERT(recv_initial_state_ == RecvInitialState::kForwarded);
   // If there was an error we just propagate that through
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     recv_initial_state_ = RecvInitialState::kResponded;
     flusher.AddClosure(
         absl::exchange(original_recv_initial_metadata_ready_, nullptr),

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

@@ -26,7 +26,6 @@
 
 #include <atomic>
 #include <new>
-#include <type_traits>
 #include <utility>
 
 #include "absl/container/inlined_vector.h"
@@ -37,6 +36,7 @@
 
 #include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -170,6 +170,7 @@ class BaseCallData : public Activity, private Wakeable {
     ~Flusher();
 
     void Resume(grpc_transport_stream_op_batch* batch) {
+      GPR_ASSERT(!call_->is_last());
       release_.push_back(batch);
     }
 

data/src/core/lib/compression/compression.cc

@@ -18,12 +18,17 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
 
+#include "absl/types/optional.h"
+
 #include <grpc/compression.h>
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/slice.h>
 
 #include "src/core/lib/compression/compression_internal.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"

data/src/core/lib/compression/compression_internal.cc

@@ -23,17 +23,14 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <cstdint>
-
 #include "absl/container/inlined_vector.h"
-#include "absl/strings/str_join.h"
+#include "absl/strings/ascii.h"
 #include "absl/strings/str_split.h"
 
-#include <grpc/compression.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/api_trace.h"
 
 namespace grpc_core {

data/src/core/lib/compression/compression_internal.h

@@ -21,14 +21,15 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <initializer_list>
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/compression.h>
+#include <grpc/impl/codegen/compression_types.h>
 #include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/slice.h>
 
 #include "src/core/lib/gprpp/bitset.h"
 #include "src/core/lib/slice/slice.h"

data/src/core/lib/compression/message_compress.cc

@@ -22,12 +22,14 @@
 
 #include <string.h>
 
+#include <zconf.h>
 #include <zlib.h>
 
+#include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
 
 #define OUTPUT_BLOCK_SIZE 1024
 

data/src/core/lib/compression/message_compress.h

@@ -21,9 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice_buffer.h>
-
-#include "src/core/lib/compression/compression_internal.h"
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/slice.h>
 
 /* compress 'input' to 'output' using 'algorithm'.
    On success, appends compressed slices to output and returns 1.

data/src/core/lib/config/core_configuration.h

@@ -20,6 +20,8 @@
 #include <atomic>
 #include <functional>
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
@@ -76,6 +78,50 @@ class CoreConfiguration {
     CoreConfiguration* Build();
   };
 
+  // Stores a builder for RegisterBuilder
+  struct RegisteredBuilder {
+    std::function<void(Builder*)> builder;
+    RegisteredBuilder* next;
+  };
+
+  // Temporarily replaces core configuration with what is built from the
+  // provided BuildFunc that takes (Builder*) and returns void.
+  // Requires no concurrent Get() be called. Restores current core
+  // configuration when this object is destroyed. The default builder
+  // is not backed up or restored.
+  //
+  // Useful for running multiple tests back to back in the same process
+  // without side effects from previous tests.
+  class WithSubstituteBuilder {
+   public:
+    template <typename BuildFunc>
+    explicit WithSubstituteBuilder(BuildFunc build) {
+      // Build core configuration to replace.
+      Builder builder;
+      build(&builder);
+      CoreConfiguration* p = builder.Build();
+
+      // Backup current core configuration and replace/reset.
+      config_restore_ =
+          CoreConfiguration::config_.exchange(p, std::memory_order_acquire);
+      builders_restore_ = CoreConfiguration::builders_.exchange(
+          nullptr, std::memory_order_acquire);
+    }
+
+    ~WithSubstituteBuilder() {
+      // Reset and restore.
+      Reset();
+      GPR_ASSERT(CoreConfiguration::config_.exchange(
+                     config_restore_, std::memory_order_acquire) == nullptr);
+      GPR_ASSERT(CoreConfiguration::builders_.exchange(
+                     builders_restore_, std::memory_order_acquire) == nullptr);
+    }
+
+   private:
+    CoreConfiguration* config_restore_;
+    RegisteredBuilder* builders_restore_;
+  };
+
   // Lifetime methods
 
   // Get the core configuration; if it does not exist, create it.
@@ -87,36 +133,11 @@ class CoreConfiguration {
     return BuildNewAndMaybeSet();
   }
 
-  // Build a special core configuration.
-  // Requires no concurrent Get() be called.
-  // Doesn't call the regular BuildCoreConfiguration function, instead calls
-  // `build`.
-  // BuildFunc is a callable that takes a Builder* and returns void.
-  // We use a template instead of std::function<void(Builder*)> to avoid
-  // including std::function in this widely used header, and to ensure no code
-  // is generated in programs that do not use this function.
-  // This is sometimes useful for testing.
-  template <typename BuildFunc>
-  static void BuildSpecialConfiguration(BuildFunc build) {
-    // Build bespoke configuration
-    Builder builder;
-    build(&builder);
-    CoreConfiguration* p = builder.Build();
-    // Swap in final configuration, deleting anything that was already present.
-    delete config_.exchange(p, std::memory_order_release);
-  }
-
   // Attach a registration function globally.
   // Each registration function is called *in addition to*
-  // BuildCoreConfiguration for the default core configuration. When using
-  // BuildSpecialConfiguration, one can use CallRegisteredBuilders to call them.
-  // Must be called before a configuration is built.
+  // BuildCoreConfiguration for the default core configuration.
   static void RegisterBuilder(std::function<void(Builder*)> builder);
 
-  // Call all registered builders.
-  // See RegisterBuilder for why you might want to call this.
-  static void CallRegisteredBuilders(Builder* builder);
-
   // Drop the core configuration. Users must ensure no other threads are
   // accessing the configuration.
   // Clears any dynamically registered builders.
@@ -128,10 +149,8 @@ class CoreConfiguration {
   template <typename BuildFunc, typename RunFunc>
   static void RunWithSpecialConfiguration(BuildFunc build_configuration,
                                           RunFunc code_to_run) {
-    Reset();
-    BuildSpecialConfiguration(build_configuration);
+    WithSubstituteBuilder builder(build_configuration);
     code_to_run();
-    Reset();
   }
 
   // Accessors
@@ -165,12 +184,6 @@ class CoreConfiguration {
  private:
   explicit CoreConfiguration(Builder* builder);
 
-  // Stores a builder for RegisterBuilder
-  struct RegisteredBuilder {
-    std::function<void(Builder*)> builder;
-    RegisteredBuilder* next;
-  };
-
   // Create a new CoreConfiguration, and either set it or throw it away.
   // We allow multiple CoreConfiguration's to be created in parallel.
   static const CoreConfiguration& BuildNewAndMaybeSet();

data/src/core/lib/debug/stats.cc

@@ -23,38 +23,35 @@
 #include <inttypes.h>
 #include <string.h>
 
+#include <algorithm>
 #include <vector>
 
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
-
-grpc_stats_data* grpc_stats_per_cpu_storage = nullptr;
-static size_t g_num_cores;
-
-void grpc_stats_init(void) {
-  g_num_cores = std::max(1u, gpr_cpu_num_cores());
-  grpc_stats_per_cpu_storage = static_cast<grpc_stats_data*>(
-      gpr_zalloc(sizeof(grpc_stats_data) * g_num_cores));
-}
-
-void grpc_stats_shutdown(void) { gpr_free(grpc_stats_per_cpu_storage); }
+#include <grpc/support/cpu.h>
+
+namespace grpc_core {
+Stats* const g_stats_data = [] {
+  size_t num_cores = gpr_cpu_num_cores();
+  Stats* stats = static_cast<Stats*>(
+      gpr_zalloc(sizeof(Stats) + num_cores * sizeof(grpc_stats_data)));
+  stats->num_cores = num_cores;
+  return stats;
+}();
+}  // namespace grpc_core
 
 void grpc_stats_collect(grpc_stats_data* output) {
   memset(output, 0, sizeof(*output));
-  for (size_t core = 0; core < g_num_cores; core++) {
+  for (size_t core = 0; core < grpc_core::g_stats_data->num_cores; core++) {
     for (size_t i = 0; i < GRPC_STATS_COUNTER_COUNT; i++) {
       output->counters[i] += gpr_atm_no_barrier_load(
-          &grpc_stats_per_cpu_storage[core].counters[i]);
+          &grpc_core::g_stats_data->per_cpu[core].counters[i]);
     }
     for (size_t i = 0; i < GRPC_STATS_HISTOGRAM_BUCKETS; i++) {
       output->histograms[i] += gpr_atm_no_barrier_load(
-          &grpc_stats_per_cpu_storage[core].histograms[i]);
+          &grpc_core::g_stats_data->per_cpu[core].histograms[i]);
     }
   }
 }