grpc 1.41.0 → 1.42.0.pre1

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

@@ -15,11 +15,12 @@
 #ifndef GRPC_CORE_LIB_CONFIG_CORE_CONFIGURATION_H
 #define GRPC_CORE_LIB_CONFIG_CORE_CONFIGURATION_H
 
-#include <grpc/impl/codegen/port_platform.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 {
 
@@ -34,6 +35,8 @@ class CoreConfiguration {
   // their configuration and assemble the published CoreConfiguration.
   class Builder {
    public:
+    ChannelInit::Builder* channel_init() { return &channel_init_; }
+
     HandshakerRegistry::Builder* handshaker_registry() {
       return &handshaker_registry_;
     }
@@ -41,6 +44,7 @@ class CoreConfiguration {
    private:
     friend class CoreConfiguration;
 
+    ChannelInit::Builder channel_init_;
     HandshakerRegistry::Builder handshaker_registry_;
 
     Builder();
@@ -77,13 +81,38 @@ class CoreConfiguration {
     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_;
   }
@@ -91,13 +120,22 @@ 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();
 
   // The configuration
   static std::atomic<CoreConfiguration*> config_;
+  // Extra registered builders
+  static std::atomic<RegisteredBuilder*> builders_;
 
+  ChannelInit channel_init_;
   HandshakerRegistry handshaker_registry_;
 };
 

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_data.cc

@@ -353,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;
@@ -376,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;
@@ -399,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;
@@ -422,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;
@@ -445,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;
@@ -468,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;
@@ -491,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);
@@ -516,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);
@@ -541,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);
@@ -566,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);
@@ -591,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);
@@ -616,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);
@@ -641,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/gpr/atm.cc

@@ -28,7 +28,7 @@ gpr_atm gpr_atm_no_barrier_clamped_add(gpr_atm* value, gpr_atm delta,
   gpr_atm new_value;
   do {
     current_value = gpr_atm_no_barrier_load(value);
-    new_value = GPR_CLAMP(current_value + delta, min, max);
+    new_value = grpc_core::Clamp(current_value + delta, min, max);
     if (new_value == current_value) break;
   } while (!gpr_atm_no_barrier_cas(value, current_value, new_value));
   return new_value;

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

@@ -77,7 +77,7 @@ unsigned gpr_cpu_current_cpu(void) {
     pthread_setspecific(thread_id_key, thread_id);
   }
 
-  return (unsigned)GPR_HASH_POINTER(thread_id, gpr_cpu_num_cores());
+  return (unsigned)grpc_core::HashPointer(thread_id, gpr_cpu_num_cores());
 }
 
 #endif /* GPR_CPU_POSIX */

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

@@ -89,7 +89,7 @@ static dump_out dump_out_create(void) {
 
 static void dump_out_append(dump_out* out, char c) {
   if (out->length == out->capacity) {
-    out->capacity = GPR_MAX(8, 2 * out->capacity);
+    out->capacity = std::max(size_t(8), 2 * out->capacity);
     out->data = static_cast<char*>(gpr_realloc(out->data, out->capacity));
   }
   out->data[out->length++] = c;
@@ -290,7 +290,7 @@ static void add_string_to_split(const char* beg, const char* end, char*** strs,
   memcpy(out, beg, static_cast<size_t>(end - beg));
   out[end - beg] = 0;
   if (*nstrs == *capstrs) {
-    *capstrs = GPR_MAX(8, 2 * *capstrs);
+    *capstrs = std::max(size_t(8), 2 * *capstrs);
     *strs = static_cast<char**>(gpr_realloc(*strs, sizeof(*strs) * *capstrs));
   }
   (*strs)[*nstrs] = out;

data/src/core/lib/gpr/tls.h

@@ -19,7 +19,7 @@
 #ifndef GRPC_CORE_LIB_GPR_TLS_H
 #define GRPC_CORE_LIB_GPR_TLS_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include <type_traits>
 

data/src/core/lib/gpr/useful.h

@@ -19,48 +19,95 @@
 #ifndef GRPC_CORE_LIB_GPR_USEFUL_H
 #define GRPC_CORE_LIB_GPR_USEFUL_H
 
-/** useful macros that don't belong anywhere else */
+#include <grpc/support/port_platform.h>
+
+#include <cstddef>
+
+/** useful utilities that don't belong anywhere else */
+
+namespace grpc_core {
+
+template <typename T>
+T Clamp(T val, T min, T max) {
+  if (val < min) return min;
+  if (max < val) return max;
+  return val;
+}
 
-#define GPR_MIN(a, b) ((a) < (b) ? (a) : (b))
-#define GPR_MAX(a, b) ((a) > (b) ? (a) : (b))
-#define GPR_CLAMP(a, min, max) ((a) < (min) ? (min) : (a) > (max) ? (max) : (a))
 /** rotl, rotr assume x is unsigned */
-#define GPR_ROTL(x, n) (((x) << (n)) | ((x) >> (sizeof(x) * 8 - (n))))
-#define GPR_ROTR(x, n) (((x) >> (n)) | ((x) << (sizeof(x) * 8 - (n))))
+template <typename T>
+constexpr T RotateLeft(T x, T n) {
+  return ((x << n) | (x >> (sizeof(x) * 8 - n)));
+}
+template <typename T>
+constexpr T RotateRight(T x, T n) {
+  return ((x >> n) | (x << (sizeof(x) * 8 - n)));
+}
 
-#define GPR_ARRAY_SIZE(array) (sizeof(array) / sizeof(*(array)))
+// Set the n-th bit of i
+template <typename T>
+T SetBit(T* i, size_t n) {
+  return *i |= (T(1) << n);
+}
+
+// Clear the n-th bit of i
+template <typename T>
+T ClearBit(T* i, size_t n) {
+  return *i &= ~(T(1) << n);
+}
 
-#define GPR_SWAP(type, a, b) \
-  do {                       \
-    type x = a;              \
-    (a) = b;                 \
-    (b) = x;                 \
-  } while (0)
+// Get the n-th bit of i
+template <typename T>
+bool GetBit(T i, size_t n) {
+  return (i & (T(1) << n)) != 0;
+}
 
-/** Set the \a n-th bit of \a i (a mutable pointer). */
-#define GPR_BITSET(i, n) ((*(i)) |= (1u << (n)))
+namespace useful_detail {
+inline constexpr uint32_t HexdigitBitcount(uint32_t x) {
+  return (x - ((x >> 1) & 0x77777777) - ((x >> 2) & 0x33333333) -
+          ((x >> 3) & 0x11111111));
+}
+}  // namespace useful_detail
 
-/** Clear the \a n-th bit of \a i (a mutable pointer). */
-#define GPR_BITCLEAR(i, n) ((*(i)) &= ~(1u << (n)))
+inline constexpr uint32_t BitCount(uint32_t i) {
+  return (((useful_detail::HexdigitBitcount(i) +
+            (useful_detail::HexdigitBitcount(i) >> 4)) &
+           0x0f0f0f0f) %
+          255);
+}
 
-/** Get the \a n-th bit of \a i */
-#define GPR_BITGET(i, n) (((i) & (1u << (n))) != 0)
+inline constexpr uint32_t BitCount(uint64_t i) {
+  return BitCount(uint32_t(i)) + BitCount(uint32_t(i >> 32));
+}
 
-#define GPR_INTERNAL_HEXDIGIT_BITCOUNT(x)                        \
-  ((x) - (((x) >> 1) & 0x77777777) - (((x) >> 2) & 0x33333333) - \
-   (((x) >> 3) & 0x11111111))
+inline constexpr uint32_t BitCount(uint16_t i) { return BitCount(uint32_t(i)); }
+inline constexpr uint32_t BitCount(uint8_t i) { return BitCount(uint32_t(i)); }
+inline constexpr uint32_t BitCount(int64_t i) { return BitCount(uint64_t(i)); }
+inline constexpr uint32_t BitCount(int32_t i) { return BitCount(uint32_t(i)); }
+inline constexpr uint32_t BitCount(int16_t i) { return BitCount(uint16_t(i)); }
+inline constexpr uint32_t BitCount(int8_t i) { return BitCount(uint8_t(i)); }
 
-/** Returns number of bits set in bitset \a i */
-#define GPR_BITCOUNT(i)                          \
-  (((GPR_INTERNAL_HEXDIGIT_BITCOUNT(i) +         \
-     (GPR_INTERNAL_HEXDIGIT_BITCOUNT(i) >> 4)) & \
-    0x0f0f0f0f) %                                \
-   255)
+// This function uses operator< to implement a qsort-style comparison, whereby:
+// if a is smaller than b, a number smaller than 0 is returned.
+// if a is bigger than b, a number greater than 0 is returned.
+// if a is neither smaller nor bigger than b, 0 is returned.
+template <typename T>
+int QsortCompare(const T& a, const T& b) {
+  if (a < b) return -1;
+  if (b < a) return 1;
+  return 0;
+}
 
-#define GPR_ICMP(a, b) ((a) < (b) ? -1 : ((a) > (b) ? 1 : 0))
+template <typename T>
+constexpr size_t HashPointer(T* p, size_t range) {
+  return (((reinterpret_cast<size_t>(p)) >> 4) ^
+          ((reinterpret_cast<size_t>(p)) >> 9) ^
+          ((reinterpret_cast<size_t>(p)) >> 14)) %
+         range;
+}
 
-#define GPR_HASH_POINTER(x, range)                                         \
-  (((((size_t)(x)) >> 4) ^ (((size_t)(x)) >> 9) ^ (((size_t)(x)) >> 14)) % \
-   (range))
+}  // namespace grpc_core
+
+#define GPR_ARRAY_SIZE(array) (sizeof(array) / sizeof(*(array)))
 
 #endif /* GRPC_CORE_LIB_GPR_USEFUL_H */

data/src/core/lib/gprpp/arena.h

@@ -30,6 +30,7 @@
 #include <stddef.h>
 
 #include <atomic>
+#include <memory>
 #include <new>
 #include <utility>
 
@@ -116,6 +117,15 @@ class Arena {
   Zone* last_zone_ = nullptr;
 };
 
+// Smart pointer for arenas when the final size is not required.
+struct ScopedArenaDeleter {
+  void operator()(Arena* arena) { arena->Destroy(); }
+};
+using ScopedArenaPtr = std::unique_ptr<Arena, ScopedArenaDeleter>;
+inline ScopedArenaPtr MakeScopedArena(size_t initial_size) {
+  return ScopedArenaPtr(Arena::Create(initial_size));
+}
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_ARENA_H */

data/src/core/lib/gprpp/bitset.h

@@ -15,10 +15,12 @@
 #ifndef GRPC_CORE_LIB_GPRPP_BITSET_H
 #define GRPC_CORE_LIB_GPRPP_BITSET_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include <utility>
 
+#include "src/core/lib/gpr/useful.h"
+
 #if __cplusplus > 201103l
 #define GRPC_BITSET_CONSTEXPR_MUTATOR constexpr
 #else
@@ -29,7 +31,7 @@ namespace grpc_core {
 
 // Given a bit count as an integer, vend as member type `Type` a type with
 // exactly that number of bits. Undefined if that bit count is not available.
-template <std::size_t kBits>
+template <size_t kBits>
 struct UintSelector;
 template <>
 struct UintSelector<8> {
@@ -49,7 +51,7 @@ struct UintSelector<64> {
 };
 
 // An unsigned integer of some number of bits.
-template <std::size_t kBits>
+template <size_t kBits>
 using Uint = typename UintSelector<kBits>::Type;
 
 // Given the total number of bits that need to be stored, choose the size of
@@ -58,7 +60,7 @@ using Uint = typename UintSelector<kBits>::Type;
 // size and performance
 // - the details will likely be tweaked into the future.
 // Once we get over 96 bits, we just use uint64_t for everything.
-constexpr std::size_t ChooseUnitBitsForBitSet(std::size_t total_bits) {
+constexpr size_t ChooseUnitBitsForBitSet(size_t total_bits) {
   return total_bits <= 8    ? 8
          : total_bits <= 16 ? 16
          : total_bits <= 24 ? 8
@@ -74,11 +76,10 @@ constexpr std::size_t ChooseUnitBitsForBitSet(std::size_t total_bits) {
 // kUnitBits. e.g. to store 72 bits in 8 bit chunks, we'd say BitSet<72, 8>.
 // Since most users shouldn't care about the size of unit used, we default
 // kUnitBits to whatever is selected by ChooseUnitBitsForBitSet
-template <std::size_t kTotalBits,
-          std::size_t kUnitBits = ChooseUnitBitsForBitSet(kTotalBits)>
+template <size_t kTotalBits,
+          size_t kUnitBits = ChooseUnitBitsForBitSet(kTotalBits)>
 class BitSet {
-  static constexpr std::size_t kUnits =
-      (kTotalBits + kUnitBits - 1) / kUnitBits;
+  static constexpr size_t kUnits = (kTotalBits + kUnitBits - 1) / kUnitBits;
 
  public:
   // Initialize to all bits false
@@ -113,7 +114,7 @@ class BitSet {
     if (kTotalBits % kUnitBits == 0) {
       // kTotalBits is a multiple of kUnitBits ==> we can just check for all
       // ones in each unit.
-      for (std::size_t i = 0; i < kUnits; i++) {
+      for (size_t i = 0; i < kUnits; i++) {
         if (units_[i] != all_ones()) return false;
       }
       return true;
@@ -121,7 +122,7 @@ class BitSet {
       // kTotalBits is not a multiple of kUnitBits ==> we need special handling
       // for checking partial filling of the last unit (since not all of its
       // bits are used!)
-      for (std::size_t i = 0; i < kUnits - 1; i++) {
+      for (size_t i = 0; i < kUnits - 1; i++) {
         if (units_[i] != all_ones()) return false;
       }
       return units_[kUnits - 1] == n_ones(kTotalBits % kUnitBits);
@@ -130,20 +131,27 @@ class BitSet {
 
   // Return true if *no* bits are set.
   bool none() const {
-    for (std::size_t i = 0; i < kUnits; i++) {
+    for (size_t i = 0; i < kUnits; i++) {
       if (units_[i] != 0) return false;
     }
     return true;
   }
 
+  // Return a count of how many bits are set.
+  uint32_t count() const {
+    uint32_t count = 0;
+    for (size_t i = 0; i < kUnits; i++) {
+      count += BitCount(units_[i]);
+    }
+    return count;
+  }
+
  private:
   // Given a bit index, return which unit it's stored in.
-  static constexpr std::size_t unit_for(std::size_t bit) {
-    return bit / kUnitBits;
-  }
+  static constexpr size_t unit_for(size_t bit) { return bit / kUnitBits; }
 
   // Given a bit index, return a mask to access that bit within it's unit.
-  static constexpr Uint<kUnitBits> mask_for(std::size_t bit) {
+  static constexpr Uint<kUnitBits> mask_for(size_t bit) {
     return Uint<kUnitBits>{1} << (bit % kUnitBits);
   }
 
@@ -153,7 +161,7 @@ class BitSet {
   }
 
   // Return a value with n bottom bits ones
-  static constexpr Uint<kUnitBits> n_ones(std::size_t n) {
+  static constexpr Uint<kUnitBits> n_ones(size_t n) {
     return n == kUnitBits ? all_ones() : (Uint<kUnitBits>(1) << n) - 1;
   }
 
@@ -161,6 +169,20 @@ class BitSet {
   Uint<kUnitBits> units_[kUnits];
 };
 
+// Zero-size specialization of BitSet.
+// Useful for generic programming.
+// Make a compile time error out of get/set type accesses, and hard-codes
+// queries that do make sense.
+template <>
+class BitSet<0> {
+ public:
+  constexpr BitSet() {}
+
+  bool all() const { return true; }
+  bool none() const { return true; }
+  uint32_t count() const { return 0; }
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_LIB_GPRPP_BITSET_H