grpc 1.40.0.pre1 → 1.42.0.pre1

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

@@ -21,6 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+#include <vector>
+
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/channel/handshaker_factory.h"
@@ -35,18 +38,32 @@ typedef enum {
 
 class HandshakerRegistry {
  public:
-  /// Registers a new handshaker factory.  Takes ownership.
-  /// If \a at_start is true, the new handshaker will be at the beginning of
-  /// the list.  Otherwise, it will be added to the end.
-  static void RegisterHandshakerFactory(
-      bool at_start, HandshakerType handshaker_type,
-      std::unique_ptr<HandshakerFactory> factory);
-  static void AddHandshakers(HandshakerType handshaker_type,
-                             const grpc_channel_args* args,
-                             grpc_pollset_set* interested_parties,
-                             HandshakeManager* handshake_mgr);
-  static void Init();
-  static void Shutdown();
+  class Builder {
+   public:
+    /// Registers a new handshaker factory.  Takes ownership.
+    /// If \a at_start is true, the new handshaker will be at the beginning of
+    /// the list.  Otherwise, it will be added to the end.
+    void RegisterHandshakerFactory(bool at_start,
+                                   HandshakerType handshaker_type,
+                                   std::unique_ptr<HandshakerFactory> factory);
+
+    HandshakerRegistry Build();
+
+   private:
+    std::vector<std::unique_ptr<HandshakerFactory>>
+        factories_[NUM_HANDSHAKER_TYPES];
+  };
+
+  void AddHandshakers(HandshakerType handshaker_type,
+                      const grpc_channel_args* args,
+                      grpc_pollset_set* interested_parties,
+                      HandshakeManager* handshake_mgr) const;
+
+ private:
+  HandshakerRegistry() = default;
+
+  std::vector<std::unique_ptr<HandshakerFactory>>
+      factories_[NUM_HANDSHAKER_TYPES];
 };
 
 }  // namespace grpc_core

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

@@ -21,11 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/status.h>
-
 #include <stdbool.h>
 #include <string.h>
 
+#include <grpc/status.h>
+
 /// If \a status_str is a valid status string, sets \a status to the
 /// corresponding status value and returns true.
 bool grpc_status_code_from_string(const char* status_str,

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

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/compression.h>
+
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/transport/metadata.h"
 

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

@@ -116,12 +116,12 @@ void grpc_compression_options_init(grpc_compression_options* opts) {
 
 void grpc_compression_options_enable_algorithm(
     grpc_compression_options* opts, grpc_compression_algorithm algorithm) {
-  GPR_BITSET(&opts->enabled_algorithms_bitset, algorithm);
+  grpc_core::SetBit(&opts->enabled_algorithms_bitset, algorithm);
 }
 
 void grpc_compression_options_disable_algorithm(
     grpc_compression_options* opts, grpc_compression_algorithm algorithm) {
-  GPR_BITCLEAR(&opts->enabled_algorithms_bitset, algorithm);
+  grpc_core::ClearBit(&opts->enabled_algorithms_bitset, algorithm);
 }
 
 int grpc_compression_options_is_algorithm_enabled(

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/compression/compression_args.h"
+
 #include <limits.h>
 #include <string.h>
 
@@ -28,7 +30,6 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/compression/compression_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 
@@ -100,9 +101,9 @@ grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
             algo_name);
   } else if (states_arg_found) {
     if (state != 0) {
-      GPR_BITSET((unsigned*)states_arg, algorithm);
+      grpc_core::SetBit(reinterpret_cast<unsigned*>(states_arg), algorithm);
     } else if (algorithm != GRPC_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned*)states_arg, algorithm);
+      grpc_core::ClearBit(reinterpret_cast<unsigned*>(states_arg), algorithm);
     }
   } else {
     /* create a new arg */
@@ -113,9 +114,11 @@ grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
     /* all enabled by default */
     tmp.value.integer = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
     if (state != 0) {
-      GPR_BITSET((unsigned*)&tmp.value.integer, algorithm);
+      grpc_core::SetBit(reinterpret_cast<unsigned*>(&tmp.value.integer),
+                        algorithm);
     } else if (algorithm != GRPC_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned*)&tmp.value.integer, algorithm);
+      grpc_core::ClearBit(reinterpret_cast<unsigned*>(&tmp.value.integer),
+                          algorithm);
     }
     result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
     grpc_channel_args_destroy(*a);

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

@@ -18,13 +18,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/compression/compression_internal.h"
+
 #include <stdlib.h>
 #include <string.h>
 
 #include <grpc/compression.h>
 
 #include "src/core/lib/compression/algorithm_metadata.h"
-#include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/surface/api_trace.h"
@@ -168,7 +169,6 @@ int grpc_compression_algorithm_from_message_stream_compression_algorithm(
         return 0;
     }
   }
-  return 0;
 }
 
 /* Interfaces for message compression. */
@@ -207,7 +207,7 @@ grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level(
   }
 
   const size_t num_supported =
-      GPR_BITCOUNT(accepted_encodings) - 1; /* discard NONE */
+      grpc_core::BitCount(accepted_encodings) - 1; /* discard NONE */
   if (level == GRPC_COMPRESS_LEVEL_NONE || num_supported == 0) {
     return GRPC_MESSAGE_COMPRESS_NONE;
   }
@@ -228,7 +228,7 @@ grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level(
   for (size_t i = 0; i < GPR_ARRAY_SIZE(algos_ranking); i++) {
     const grpc_message_compression_algorithm alg = algos_ranking[i];
     for (size_t j = 0; j < num_supported; j++) {
-      if (GPR_BITGET(accepted_encodings, alg) == 1) {
+      if (grpc_core::GetBit(accepted_encodings, alg) == 1) {
         /* if \a alg in supported */
         sorted_supported_algos[algos_supported_idx++] = alg;
         break;
@@ -265,7 +265,6 @@ int grpc_message_compression_algorithm_parse(
   } else {
     return 0;
   }
-  return 0;
 }
 
 /* Interfaces for stream compression. */
@@ -281,5 +280,4 @@ int grpc_stream_compression_algorithm_parse(
   } else {
     return 0;
   }
-  return 0;
 }

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

@@ -91,7 +91,7 @@ int grpc_stream_compression_algorithm_parse(
 inline int grpc_compression_options_is_algorithm_enabled_internal(
     const grpc_compression_options* opts,
     grpc_compression_algorithm algorithm) {
-  return GPR_BITGET(opts->enabled_algorithms_bitset, algorithm);
+  return grpc_core::GetBit(opts->enabled_algorithms_bitset, algorithm);
 }
 
 #endif /* GRPC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H */

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

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

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

@@ -18,9 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/compression/stream_compression.h"
+
 #include <grpc/support/log.h>
 
-#include "src/core/lib/compression/stream_compression.h"
 #include "src/core/lib/compression/stream_compression_gzip.h"
 #include "src/core/lib/slice/slice_utils.h"
 

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

@@ -23,9 +23,10 @@
 
 #include <stdbool.h>
 
-#include <grpc/slice_buffer.h>
 #include <zlib.h>
 
+#include <grpc/slice_buffer.h>
+
 #include "src/core/lib/transport/static_metadata.h"
 
 typedef struct grpc_stream_compression_vtable grpc_stream_compression_vtable;

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

@@ -18,10 +18,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/compression/stream_compression_gzip.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/compression/stream_compression_gzip.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
 

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

@@ -18,10 +18,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/compression/stream_compression_identity.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/compression/stream_compression_identity.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 #define OUTPUT_BLOCK_SIZE (1024)

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

@@ -0,0 +1,96 @@
+// Copyright 2021 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>
+
+#include "src/core/lib/config/core_configuration.h"
+
+#include <grpc/support/log.h>
+
+namespace grpc_core {
+
+std::atomic<CoreConfiguration*> CoreConfiguration::config_{nullptr};
+std::atomic<CoreConfiguration::RegisteredBuilder*> CoreConfiguration::builders_{
+    nullptr};
+
+CoreConfiguration::Builder::Builder() = default;
+
+CoreConfiguration* CoreConfiguration::Builder::Build() {
+  return new CoreConfiguration(this);
+}
+
+CoreConfiguration::CoreConfiguration(Builder* builder)
+    : channel_init_(builder->channel_init_.Build()),
+      handshaker_registry_(builder->handshaker_registry_.Build()) {}
+
+void CoreConfiguration::RegisterBuilder(std::function<void(Builder*)> builder) {
+  GPR_ASSERT(config_.load(std::memory_order_relaxed) == nullptr &&
+             "CoreConfiguration was already instantiated before builder "
+             "registration was completed");
+  RegisteredBuilder* n = new RegisteredBuilder();
+  n->builder = std::move(builder);
+  n->next = builders_.load(std::memory_order_relaxed);
+  while (!builders_.compare_exchange_weak(n->next, n, std::memory_order_acq_rel,
+                                          std::memory_order_relaxed)) {
+  }
+  GPR_ASSERT(config_.load(std::memory_order_relaxed) == nullptr &&
+             "CoreConfiguration was already instantiated before builder "
+             "registration was completed");
+}
+
+const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {
+  // Construct builder, pass it up to code that knows about build configuration
+  Builder builder;
+  // The linked list of builders stores things in reverse registration order.
+  // To get things registered as systems relying on this expect however, we
+  // actually need to run things in forward registration order, so we iterate
+  // once over the linked list to build a vector of builders, and then iterate
+  // over said vector in reverse to actually run the builders.
+  std::vector<RegisteredBuilder*> registered_builders;
+  for (RegisteredBuilder* b = builders_.load(std::memory_order_acquire);
+       b != nullptr; b = b->next) {
+    registered_builders.push_back(b);
+  }
+  for (auto it = registered_builders.rbegin(); it != registered_builders.rend();
+       ++it) {
+    (*it)->builder(&builder);
+  }
+  // Finally, call the built in configuration builder.
+  BuildCoreConfiguration(&builder);
+  // Use builder to construct a confguration
+  CoreConfiguration* p = builder.Build();
+  // Try to set configuration global - it's possible another thread raced us
+  // here, in which case we drop the work we did and use the one that got set
+  // first
+  CoreConfiguration* expected = nullptr;
+  if (!config_.compare_exchange_strong(expected, p, std::memory_order_acq_rel,
+                                       std::memory_order_acquire)) {
+    delete p;
+    return *expected;
+  }
+  return *p;
+}
+
+void CoreConfiguration::Reset() {
+  delete config_.exchange(nullptr, std::memory_order_acquire);
+  RegisteredBuilder* builder =
+      builders_.exchange(nullptr, std::memory_order_acquire);
+  while (builder != nullptr) {
+    RegisteredBuilder* next = builder->next;
+    delete builder;
+    builder = next;
+  }
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,146 @@
+// Copyright 2021 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_CONFIG_CORE_CONFIGURATION_H
+#define GRPC_CORE_LIB_CONFIG_CORE_CONFIGURATION_H
+
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+
+#include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/surface/channel_init.h"
+
+namespace grpc_core {
+
+// Global singleton that stores library configuration - factories, etc...
+// that plugins might choose to extend.
+class CoreConfiguration {
+ public:
+  CoreConfiguration(const CoreConfiguration&) = delete;
+  CoreConfiguration& operator=(const CoreConfiguration&) = delete;
+
+  // Builder is passed to plugins, etc... at initialization time to collect
+  // their configuration and assemble the published CoreConfiguration.
+  class Builder {
+   public:
+    ChannelInit::Builder* channel_init() { return &channel_init_; }
+
+    HandshakerRegistry::Builder* handshaker_registry() {
+      return &handshaker_registry_;
+    }
+
+   private:
+    friend class CoreConfiguration;
+
+    ChannelInit::Builder channel_init_;
+    HandshakerRegistry::Builder handshaker_registry_;
+
+    Builder();
+    CoreConfiguration* Build();
+  };
+
+  // Lifetime methods
+
+  // Get the core configuration; if it does not exist, create it.
+  static const CoreConfiguration& Get() {
+    CoreConfiguration* p = config_.load(std::memory_order_acquire);
+    if (p != nullptr) {
+      return *p;
+    }
+    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.
+  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.
+  static void Reset();
+
+  // Helper for tests: Reset the configuration, build a special one, run some
+  // code, and then reset the configuration again.
+  // Templatized to be sure no codegen in normal builds.
+  template <typename BuildFunc, typename RunFunc>
+  static void RunWithSpecialConfiguration(BuildFunc build_configuration,
+                                          RunFunc code_to_run) {
+    Reset();
+    BuildSpecialConfiguration(build_configuration);
+    code_to_run();
+    Reset();
+  }
+
+  // Accessors
+
+  const ChannelInit& channel_init() const { return channel_init_; }
+
+  const HandshakerRegistry& handshaker_registry() const {
+    return handshaker_registry_;
+  }
+
+ 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();
+
+  // The configuration
+  static std::atomic<CoreConfiguration*> config_;
+  // Extra registered builders
+  static std::atomic<RegisteredBuilder*> builders_;
+
+  ChannelInit channel_init_;
+  HandshakerRegistry handshaker_registry_;
+};
+
+extern void BuildCoreConfiguration(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_CONFIG_CORE_CONFIGURATION_H */

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

@@ -38,7 +38,7 @@ grpc_stats_data* grpc_stats_per_cpu_storage = nullptr;
 static size_t g_num_cores;
 
 void grpc_stats_init(void) {
-  g_num_cores = GPR_MAX(1, gpr_cpu_num_cores());
+  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));
 }

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

@@ -24,6 +24,7 @@
 #include <string>
 
 #include <grpc/support/atm.h>
+
 #include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 

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

@@ -20,8 +20,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/stats_data.h"
+
+#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
@@ -352,7 +353,7 @@ const uint8_t grpc_stats_table_7[102] = {
 const int grpc_stats_table_8[9] = {0, 1, 2, 4, 7, 13, 23, 39, 64};
 const uint8_t grpc_stats_table_9[9] = {0, 0, 1, 2, 2, 3, 4, 4, 5};
 void grpc_stats_inc_call_initial_size(int value) {
-  value = GPR_CLAMP(value, 0, 262144);
+  value = grpc_core::Clamp(value, 0, 262144);
   if (value < 6) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE, value);
     return;
@@ -375,7 +376,7 @@ void grpc_stats_inc_call_initial_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_0, 64));
 }
 void grpc_stats_inc_poll_events_returned(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 29) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_POLL_EVENTS_RETURNED, value);
     return;
@@ -398,7 +399,7 @@ void grpc_stats_inc_poll_events_returned(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_2, 128));
 }
 void grpc_stats_inc_tcp_write_size(int value) {
-  value = GPR_CLAMP(value, 0, 16777216);
+  value = grpc_core::Clamp(value, 0, 16777216);
   if (value < 5) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE, value);
     return;
@@ -421,7 +422,7 @@ void grpc_stats_inc_tcp_write_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
 void grpc_stats_inc_tcp_write_iov_size(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE, value);
     return;
@@ -444,7 +445,7 @@ void grpc_stats_inc_tcp_write_iov_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_tcp_read_size(int value) {
-  value = GPR_CLAMP(value, 0, 16777216);
+  value = grpc_core::Clamp(value, 0, 16777216);
   if (value < 5) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_SIZE, value);
     return;
@@ -467,7 +468,7 @@ void grpc_stats_inc_tcp_read_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
 void grpc_stats_inc_tcp_read_offer(int value) {
-  value = GPR_CLAMP(value, 0, 16777216);
+  value = grpc_core::Clamp(value, 0, 16777216);
   if (value < 5) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_OFFER, value);
     return;
@@ -490,7 +491,7 @@ void grpc_stats_inc_tcp_read_offer(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
 void grpc_stats_inc_tcp_read_offer_iov_size(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE,
                              value);
@@ -515,7 +516,7 @@ void grpc_stats_inc_tcp_read_offer_iov_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_http2_send_message_size(int value) {
-  value = GPR_CLAMP(value, 0, 16777216);
+  value = grpc_core::Clamp(value, 0, 16777216);
   if (value < 5) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE,
                              value);
@@ -540,7 +541,7 @@ void grpc_stats_inc_http2_send_message_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
 void grpc_stats_inc_http2_send_initial_metadata_per_write(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(
         GRPC_STATS_HISTOGRAM_HTTP2_SEND_INITIAL_METADATA_PER_WRITE, value);
@@ -565,7 +566,7 @@ void grpc_stats_inc_http2_send_initial_metadata_per_write(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_http2_send_message_per_write(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_PER_WRITE,
                              value);
@@ -590,7 +591,7 @@ void grpc_stats_inc_http2_send_message_per_write(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_http2_send_trailing_metadata_per_write(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(
         GRPC_STATS_HISTOGRAM_HTTP2_SEND_TRAILING_METADATA_PER_WRITE, value);
@@ -615,7 +616,7 @@ void grpc_stats_inc_http2_send_trailing_metadata_per_write(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_http2_send_flowctl_per_write(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE,
                              value);
@@ -640,7 +641,7 @@ void grpc_stats_inc_http2_send_flowctl_per_write(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_server_cqs_checked(int value) {
-  value = GPR_CLAMP(value, 0, 64);
+  value = grpc_core::Clamp(value, 0, 64);
   if (value < 3) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED, value);
     return;

data/src/core/lib/debug/stats_data.h

@@ -24,6 +24,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <inttypes.h>
+
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 typedef enum {