grpc 1.41.0.pre2 → 1.42.0

data/src/core/ext/xds/xds_client.h

@@ -102,18 +102,6 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
   grpc_pollset_set* interested_parties() const { return interested_parties_; }
 
-  // TODO(roth): When we add federation, there will be multiple channels
-  // inside the XdsClient, and the set of channels may change over time,
-  // but not every channel may use every one of the child channels, so
-  // this API will need to change.  At minumum, we will need to hold a
-  // ref to the parent channelz node so that we can update its list of
-  // children as the set of xDS channels changes.  However, we may also
-  // want to make this a bit more selective such that only those
-  // channels on which a given parent channel is actually requesting
-  // resources will actually be marked as its children.
-  void AddChannelzLinkage(channelz::ChannelNode* parent_channelz_node);
-  void RemoveChannelzLinkage(channelz::ChannelNode* parent_channelz_node);
-
   void Orphan() override;
 
   // Start and cancel listener data watch for a listener.
@@ -210,12 +198,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
  private:
   // Contains a channel to the xds server and all the data related to the
   // channel.  Holds a ref to the xds client object.
-  //
-  // Currently, there is only one ChannelState object per XdsClient
-  // object, and it has essentially the same lifetime.  But in the
-  // future, when we add federation support, a single XdsClient may have
-  // multiple underlying channels to talk to different xDS servers.
-  class ChannelState : public InternallyRefCounted<ChannelState> {
+  class ChannelState : public DualRefCounted<ChannelState> {
    public:
     template <typename T>
     class RetryableCall;
@@ -243,9 +226,11 @@ class XdsClient : public DualRefCounted<XdsClient> {
     void StartConnectivityWatchLocked();
     void CancelConnectivityWatchLocked();
 
-    void SubscribeLocked(const std::string& type_url, const std::string& name)
+    void SubscribeLocked(const std::string& type_url,
+                         const XdsApi::ResourceName& resource)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
-    void UnsubscribeLocked(const std::string& type_url, const std::string& name,
+    void UnsubscribeLocked(const std::string& type_url,
+                           const XdsApi::ResourceName& resource,
                            bool delay_unsubscription)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
@@ -260,11 +245,15 @@ class XdsClient : public DualRefCounted<XdsClient> {
     // The channel and its status.
     grpc_channel* channel_;
     bool shutting_down_ = false;
-    StateWatcher* watcher_ = nullptr;
+    StateWatcher* watcher_;
 
     // The retryable XDS calls.
     OrphanablePtr<RetryableCall<AdsCallState>> ads_calld_;
     OrphanablePtr<RetryableCall<LrsCallState>> lrs_calld_;
+
+    // Stores the most recent accepted resource version for each resource type.
+    std::map<std::string /*type*/, std::string /*version*/>
+        resource_type_version_map_;
   };
 
   struct ListenerState {
@@ -302,6 +291,20 @@ class XdsClient : public DualRefCounted<XdsClient> {
     XdsApi::ResourceMetadata meta;
   };
 
+  struct AuthorityState {
+    RefCountedPtr<ChannelState> channel_state;
+    std::map<std::string /*listener_name*/, ListenerState> listener_map;
+    std::map<std::string /*route_config_name*/, RouteConfigState>
+        route_config_map;
+    std::map<std::string /*cluster_name*/, ClusterState> cluster_map;
+    std::map<std::string /*eds_service_name*/, EndpointState> endpoint_map;
+
+    bool HasSubscribedResources() {
+      return !listener_map.empty() || !route_config_map.empty() ||
+             !cluster_map.empty() || !endpoint_map.empty();
+    }
+  };
+
   struct LoadReportState {
     struct LocalityState {
       XdsClusterLocalityStats* locality_stats = nullptr;
@@ -324,6 +327,9 @@ class XdsClient : public DualRefCounted<XdsClient> {
       bool send_all_clusters, const std::set<std::string>& clusters)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
+  RefCountedPtr<ChannelState> GetOrCreateChannelStateLocked(
+      const XdsBootstrap::XdsServer& server) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
   std::unique_ptr<XdsBootstrap> bootstrap_;
   grpc_channel_args* args_;
   const grpc_millis request_timeout_;
@@ -333,20 +339,11 @@ class XdsClient : public DualRefCounted<XdsClient> {
 
   Mutex mu_;
 
-  // The channel for communicating with the xds server.
-  OrphanablePtr<ChannelState> chand_ ABSL_GUARDED_BY(mu_);
-
-  // One entry for each watched LDS resource.
-  std::map<std::string /*listener_name*/, ListenerState> listener_map_
-      ABSL_GUARDED_BY(mu_);
-  // One entry for each watched RDS resource.
-  std::map<std::string /*route_config_name*/, RouteConfigState>
-      route_config_map_ ABSL_GUARDED_BY(mu_);
-  // One entry for each watched CDS resource.
-  std::map<std::string /*cluster_name*/, ClusterState> cluster_map_
+  //  Map of existing xDS server channels.
+  std::map<XdsBootstrap::XdsServer, ChannelState*> xds_server_channel_map_
       ABSL_GUARDED_BY(mu_);
-  // One entry for each watched EDS resource.
-  std::map<std::string /*eds_service_name*/, EndpointState> endpoint_map_
+
+  std::map<std::string /*authority*/, AuthorityState> authority_state_map_
       ABSL_GUARDED_BY(mu_);
 
   // Load report data.
@@ -355,9 +352,17 @@ class XdsClient : public DualRefCounted<XdsClient> {
       LoadReportState>
       load_report_map_ ABSL_GUARDED_BY(mu_);
 
-  // Stores the most recent accepted resource version for each resource type.
-  std::map<std::string /*type*/, std::string /*version*/> resource_version_map_
-      ABSL_GUARDED_BY(mu_);
+  // Stores started watchers whose resource name was not parsed successfully,
+  // waiting to be cancelled or reset in Orphan().
+  std::map<ListenerWatcherInterface*, std::unique_ptr<ListenerWatcherInterface>>
+      invalid_listener_watchers_ ABSL_GUARDED_BY(mu_);
+  std::map<RouteConfigWatcherInterface*,
+           std::unique_ptr<RouteConfigWatcherInterface>>
+      invalid_route_config_watchers_ ABSL_GUARDED_BY(mu_);
+  std::map<ClusterWatcherInterface*, std::unique_ptr<ClusterWatcherInterface>>
+      invalid_cluster_watchers_ ABSL_GUARDED_BY(mu_);
+  std::map<EndpointWatcherInterface*, std::unique_ptr<EndpointWatcherInterface>>
+      invalid_endpoint_watchers_ ABSL_GUARDED_BY(mu_);
 
   bool shutting_down_ ABSL_GUARDED_BY(mu_) = false;
 };

data/src/core/ext/xds/xds_client_stats.h

@@ -46,7 +46,7 @@ class XdsLocalityName : public RefCounted<XdsLocalityName> {
   struct Less {
     bool operator()(const XdsLocalityName* lhs,
                     const XdsLocalityName* rhs) const {
-      if (lhs == nullptr || rhs == nullptr) return GPR_ICMP(lhs, rhs);
+      if (lhs == nullptr || rhs == nullptr) return QsortCompare(lhs, rhs);
       return lhs->Compare(*rhs) < 0;
     }
 

data/src/core/ext/xds/xds_server_config_fetcher.cc

@@ -353,12 +353,12 @@ class XdsServerConfigFetcher : public grpc_server_config_fetcher {
     GPR_ASSERT(xds_client_ != nullptr);
   }
 
-  void StartWatch(std::string listening_address, grpc_channel_args* args,
+  void StartWatch(std::string listening_address,
                   std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
                       watcher) override {
     grpc_server_config_fetcher::WatcherInterface* watcher_ptr = watcher.get();
     auto listener_watcher = absl::make_unique<ListenerWatcher>(
-        std::move(watcher), args, xds_client_, serving_status_notifier_,
+        std::move(watcher), xds_client_, serving_status_notifier_,
         listening_address);
     auto* listener_watcher_ptr = listener_watcher.get();
     listening_address = absl::StrReplaceAll(
@@ -396,17 +396,14 @@ class XdsServerConfigFetcher : public grpc_server_config_fetcher {
     explicit ListenerWatcher(
         std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
             server_config_watcher,
-        grpc_channel_args* args, RefCountedPtr<XdsClient> xds_client,
+        RefCountedPtr<XdsClient> xds_client,
         grpc_server_xds_status_notifier serving_status_notifier,
         std::string listening_address)
         : server_config_watcher_(std::move(server_config_watcher)),
-          args_(args),
           xds_client_(std::move(xds_client)),
           serving_status_notifier_(serving_status_notifier),
           listening_address_(std::move(listening_address)) {}
 
-    ~ListenerWatcher() override { grpc_channel_args_destroy(args_); }
-
     // Deleted due to special handling required for args_. Copy the channel args
     // if we ever need these.
     ListenerWatcher(const ListenerWatcher&) = delete;
@@ -498,7 +495,6 @@ class XdsServerConfigFetcher : public grpc_server_config_fetcher {
    private:
     std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
         server_config_watcher_;
-    grpc_channel_args* args_;
     RefCountedPtr<XdsClient> xds_client_;
     grpc_server_xds_status_notifier serving_status_notifier_;
     std::string listening_address_;
@@ -524,10 +520,12 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
     grpc_server_xds_status_notifier notifier, const grpc_channel_args* args) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
+  args = grpc_channel_args_remove_grpc_internal(args);
   GRPC_API_TRACE("grpc_server_config_fetcher_xds_create()", 0, ());
   grpc_error_handle error = GRPC_ERROR_NONE;
   grpc_core::RefCountedPtr<grpc_core::XdsClient> xds_client =
       grpc_core::XdsClient::GetOrCreate(args, &error);
+  grpc_channel_args_destroy(args);
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "Failed to create xds client: %s",
             grpc_error_std_string(error).c_str());

data/src/core/lib/address_utils/parse_address.cc

@@ -83,6 +83,7 @@ namespace grpc_core {
 
 grpc_error_handle UnixSockaddrPopulate(absl::string_view path,
                                        grpc_resolved_address* resolved_addr) {
+  memset(resolved_addr, 0, sizeof(*resolved_addr));
   struct sockaddr_un* un =
       reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
   const size_t maxlen = sizeof(un->sun_path) - 1;
@@ -99,6 +100,7 @@ grpc_error_handle UnixSockaddrPopulate(absl::string_view path,
 
 grpc_error_handle UnixAbstractSockaddrPopulate(
     absl::string_view path, grpc_resolved_address* resolved_addr) {
+  memset(resolved_addr, 0, sizeof(*resolved_addr));
   struct sockaddr_un* un =
       reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
   const size_t maxlen = sizeof(un->sun_path) - 1;

data/src/core/lib/avl/avl.cc

@@ -23,11 +23,11 @@
 #include <assert.h>
 #include <stdlib.h>
 
+#include <algorithm>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/useful.h"
-
 grpc_avl grpc_avl_create(const grpc_avl_vtable* vtable) {
   grpc_avl out;
   out.vtable = vtable;
@@ -63,8 +63,8 @@ static long node_height(grpc_avl_node* node) {
 #ifndef NDEBUG
 static long calculate_height(grpc_avl_node* node) {
   return node == nullptr ? 0
-                         : 1 + GPR_MAX(calculate_height(node->left),
-                                       calculate_height(node->right));
+                         : 1 + std::max(calculate_height(node->left),
+                                        calculate_height(node->right));
 }
 
 static grpc_avl_node* assert_invariants(grpc_avl_node* n) {
@@ -87,7 +87,7 @@ grpc_avl_node* new_node(void* key, void* value, grpc_avl_node* left,
   node->value = value;
   node->left = assert_invariants(left);
   node->right = assert_invariants(right);
-  node->height = 1 + GPR_MAX(node_height(left), node_height(right));
+  node->height = 1 + std::max(node_height(left), node_height(right));
   return node;
 }
 

data/src/core/lib/backoff/backoff.cc

@@ -39,7 +39,7 @@ double generate_uniform_random_number(uint32_t* rng_state) {
 double generate_uniform_random_number_between(uint32_t* rng_state, double a,
                                               double b) {
   if (a == b) return a;
-  if (a > b) GPR_SWAP(double, a, b);  // make sure a < b
+  if (a > b) std::swap(a, b);  // make sure a < b
   const double range = b - a;
   return a + generate_uniform_random_number(rng_state) * range;
 }

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

@@ -25,6 +25,7 @@
 
 #include <vector>
 
+#include "absl/strings/match.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
@@ -72,6 +73,22 @@ grpc_channel_args* grpc_channel_args_copy_and_remove(
                                                    num_to_remove, nullptr, 0);
 }
 
+grpc_channel_args* grpc_channel_args_remove_grpc_internal(
+    const grpc_channel_args* src) {
+  if (src == nullptr) return nullptr;
+  // Create result.
+  grpc_channel_args* dst =
+      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
+  dst->args =
+      static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * src->num_args));
+  dst->num_args = 0;
+  for (size_t i = 0; i < src->num_args; ++i) {
+    if (absl::StartsWith(src->args[i].key, "grpc.internal.")) continue;
+    dst->args[dst->num_args++] = copy_arg(&src->args[i]);
+  }
+  return dst;
+}
+
 static bool should_remove_arg(const grpc_arg* arg, const char** to_remove,
                               size_t num_to_remove) {
   for (size_t i = 0; i < num_to_remove; ++i) {
@@ -146,7 +163,7 @@ grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
 }
 
 static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
-  int c = GPR_ICMP(a->type, b->type);
+  int c = grpc_core::QsortCompare(a->type, b->type);
   if (c != 0) return c;
   c = strcmp(a->key, b->key);
   if (c != 0) return c;
@@ -154,11 +171,12 @@ static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
     case GRPC_ARG_STRING:
       return strcmp(a->value.string, b->value.string);
     case GRPC_ARG_INTEGER:
-      return GPR_ICMP(a->value.integer, b->value.integer);
+      return grpc_core::QsortCompare(a->value.integer, b->value.integer);
     case GRPC_ARG_POINTER:
-      c = GPR_ICMP(a->value.pointer.p, b->value.pointer.p);
+      c = grpc_core::QsortCompare(a->value.pointer.p, b->value.pointer.p);
       if (c != 0) {
-        c = GPR_ICMP(a->value.pointer.vtable, b->value.pointer.vtable);
+        c = grpc_core::QsortCompare(a->value.pointer.vtable,
+                                    b->value.pointer.vtable);
         if (c == 0) {
           c = a->value.pointer.vtable->cmp(a->value.pointer.p,
                                            b->value.pointer.p);
@@ -175,7 +193,7 @@ static int cmp_key_stable(const void* ap, const void* bp) {
   const grpc_arg* const* a = static_cast<const grpc_arg* const*>(ap);
   const grpc_arg* const* b = static_cast<const grpc_arg* const*>(bp);
   int c = strcmp((*a)->key, (*b)->key);
-  if (c == 0) c = GPR_ICMP(*a, *b);
+  if (c == 0) c = grpc_core::QsortCompare(*a, *b);
   return c;
 }
 
@@ -225,7 +243,7 @@ int grpc_channel_args_compare(const grpc_channel_args* a,
                               const grpc_channel_args* b) {
   if (a == nullptr && b == nullptr) return 0;
   if (a == nullptr || b == nullptr) return a == nullptr ? -1 : 1;
-  int c = GPR_ICMP(a->num_args, b->num_args);
+  int c = grpc_core::QsortCompare(a->num_args, b->num_args);
   if (c != 0) return c;
   for (size_t i = 0; i < a->num_args; i++) {
     c = cmp_arg(&a->args[i], &b->args[i]);

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

@@ -41,6 +41,15 @@ grpc_channel_args* grpc_channel_args_copy_and_add(const grpc_channel_args* src,
                                                   const grpc_arg* to_add,
                                                   size_t num_to_add);
 
+/** Remove any channel args prefixed with 'grpc.internal.'
+ *  These are used for internal implementation details and are not intended to
+ *  be exposed to users.
+ *  Returns a new channel args instance.
+ *  Does not take ownership of \a src.
+ *  Should be called by any public API that receives channel args. */
+grpc_channel_args* grpc_channel_args_remove_grpc_internal(
+    const grpc_channel_args* src);
+
 /** Copies the arguments in \a src except for those whose keys are in
     \a to_remove. */
 grpc_channel_args* grpc_channel_args_copy_and_remove(

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

@@ -25,6 +25,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/gprpp/memory.h"
+
 typedef struct filter_node {
   struct filter_node* next;
   struct filter_node* prev;
@@ -53,15 +55,13 @@ struct grpc_channel_stack_builder_iterator {
 
 grpc_channel_stack_builder* grpc_channel_stack_builder_create(void) {
   grpc_channel_stack_builder* b =
-      static_cast<grpc_channel_stack_builder*>(gpr_zalloc(sizeof(*b)));
-
+      grpc_core::Zalloc<grpc_channel_stack_builder>();
   b->begin.filter = nullptr;
   b->end.filter = nullptr;
   b->begin.next = &b->end;
   b->begin.prev = &b->end;
   b->end.next = &b->begin;
   b->end.prev = &b->begin;
-
   return b;
 }
 

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

@@ -16,7 +16,7 @@
  *
  */
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_trace.h"
 

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

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

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

@@ -16,7 +16,7 @@
  *
  */
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channelz.h"
 
@@ -77,7 +77,7 @@ std::string BaseNode::RenderJsonString() {
 //
 
 CallCountingHelper::CallCountingHelper() {
-  num_cores_ = GPR_MAX(1, gpr_cpu_num_cores());
+  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();
@@ -398,7 +398,7 @@ void SecurityArgDestroy(void* p) {
   xds_certificate_provider->Unref();
 }
 
-int SecurityArgCmp(void* p, void* q) { return GPR_ICMP(p, q); }
+int SecurityArgCmp(void* p, void* q) { return grpc_core::QsortCompare(p, q); }
 
 const grpc_arg_pointer_vtable kChannelArgVtable = {
     SecurityArgCopy, SecurityArgDestroy, SecurityArgCmp};

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

@@ -19,7 +19,7 @@
 #ifndef GRPC_CORE_LIB_CHANNEL_CHANNELZ_H
 #define GRPC_CORE_LIB_CHANNEL_CHANNELZ_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include <atomic>
 #include <set>
@@ -41,7 +41,7 @@
 #include "src/core/lib/json/json.h"
 
 // Channel arg key for channelz node.
-#define GRPC_ARG_CHANNELZ_CHANNEL_NODE "grpc.channelz_channel_node"
+#define GRPC_ARG_CHANNELZ_CHANNEL_NODE "grpc.internal.channelz_channel_node"
 
 // Channel arg key for indicating an internal channel.
 #define GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL \

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

@@ -16,7 +16,7 @@
  *
  */
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channelz_registry.h"
 

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

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

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

@@ -232,9 +232,7 @@ static void bind_transport(grpc_channel_stack* channel_stack,
       grpc_transport_stream_size(static_cast<grpc_transport*>(t));
 }
 
-bool grpc_add_connected_filter(grpc_channel_stack_builder* builder,
-                               void* arg_must_be_null) {
-  GPR_ASSERT(arg_must_be_null == nullptr);
+bool grpc_add_connected_filter(grpc_channel_stack_builder* builder) {
   grpc_transport* t = grpc_channel_stack_builder_get_transport(builder);
   GPR_ASSERT(t != nullptr);
   return grpc_channel_stack_builder_append_filter(

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

@@ -25,8 +25,7 @@
 
 extern const grpc_channel_filter grpc_connected_filter;
 
-bool grpc_add_connected_filter(grpc_channel_stack_builder* builder,
-                               void* arg_must_be_null);
+bool grpc_add_connected_filter(grpc_channel_stack_builder* builder);
 
 /* Debug helper to dig the transport stream out of a call element */
 grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem);

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

@@ -101,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 */
@@ -114,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

@@ -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;

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/config/core_configuration.cc

@@ -12,13 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/impl/codegen/port_platform.h>
+#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;
 
@@ -27,11 +31,42 @@ CoreConfiguration* CoreConfiguration::Builder::Build() {
 }
 
 CoreConfiguration::CoreConfiguration(Builder* builder)
-    : handshaker_registry_(builder->handshaker_registry_.Build()) {}
+    : 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();
@@ -49,6 +84,13 @@ const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {
 
 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