grpc 1.44.0.pre2 → 1.45.0

data/src/core/lib/slice/slice_refcount.cc

@@ -15,3 +15,21 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/slice/slice_refcount.h"
+
+#include <chrono>
+
+namespace grpc_core {
+
+uint32_t g_hash_seed = []() {
+  auto now = std::chrono::system_clock::now();
+  auto now_since_epoch = now.time_since_epoch();
+  auto now_ns =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(now_since_epoch);
+  return static_cast<uint32_t>(now_ns.count());
+}();
+
+}  // namespace grpc_core
+
+void grpc_test_only_set_slice_hash_seed(uint32_t seed) {
+  grpc_core::g_hash_seed = seed;
+}

data/src/core/lib/slice/slice_refcount.h

@@ -27,88 +27,18 @@
 namespace grpc_core {
 
 extern uint32_t g_hash_seed;
-extern grpc_slice_refcount kNoopRefcount;
-
-// TODO(ctiller): when this is removed, remove the std::atomic* in
-// grpc_slice_refcount and just put it there directly.
-struct InternedSliceRefcount {
-  static void Destroy(void* arg) {
-    auto* rc = static_cast<InternedSliceRefcount*>(arg);
-    rc->~InternedSliceRefcount();
-    gpr_free(rc);
-  }
-
-  InternedSliceRefcount(size_t length, uint32_t hash,
-                        InternedSliceRefcount* bucket_next)
-      : base(grpc_slice_refcount::Type::INTERNED, &refcnt, Destroy, this, &sub),
-        sub(grpc_slice_refcount::Type::REGULAR, &refcnt, Destroy, this, &sub),
-        length(length),
-        hash(hash),
-        bucket_next(bucket_next) {}
-
-  ~InternedSliceRefcount();
-
-  grpc_slice_refcount base;
-  grpc_slice_refcount sub;
-  const size_t length;
-  std::atomic<size_t> refcnt{1};
-  const uint32_t hash;
-  InternedSliceRefcount* bucket_next;
-};
 
 }  // namespace grpc_core
 
-inline size_t grpc_refcounted_slice_length(const grpc_slice& slice) {
-  GPR_DEBUG_ASSERT(slice.refcount != nullptr);
-  return slice.data.refcounted.length;
-}
-
-inline const uint8_t* grpc_refcounted_slice_data(const grpc_slice& slice) {
-  GPR_DEBUG_ASSERT(slice.refcount != nullptr);
-  return slice.data.refcounted.bytes;
-}
-
-inline int grpc_slice_refcount::Eq(const grpc_slice& a, const grpc_slice& b) {
-  GPR_DEBUG_ASSERT(a.refcount != nullptr);
-  GPR_DEBUG_ASSERT(a.refcount == this);
-  switch (ref_type_) {
-    case Type::INTERNED:
-      return a.refcount == b.refcount;
-    case Type::NOP:
-    case Type::REGULAR:
-      break;
-  }
-  if (grpc_refcounted_slice_length(a) != GRPC_SLICE_LENGTH(b)) return false;
-  if (grpc_refcounted_slice_length(a) == 0) return true;
-  return 0 == memcmp(grpc_refcounted_slice_data(a), GRPC_SLICE_START_PTR(b),
-                     grpc_refcounted_slice_length(a));
-}
-
-inline uint32_t grpc_slice_refcount::Hash(const grpc_slice& slice) {
-  GPR_DEBUG_ASSERT(slice.refcount != nullptr);
-  GPR_DEBUG_ASSERT(slice.refcount == this);
-  switch (ref_type_) {
-    case Type::INTERNED:
-      return reinterpret_cast<grpc_core::InternedSliceRefcount*>(slice.refcount)
-          ->hash;
-    case Type::NOP:
-    case Type::REGULAR:
-      break;
-  }
-  return gpr_murmur_hash3(grpc_refcounted_slice_data(slice),
-                          grpc_refcounted_slice_length(slice),
-                          grpc_core::g_hash_seed);
-}
-
 inline const grpc_slice& grpc_slice_ref_internal(const grpc_slice& slice) {
-  if (slice.refcount) {
+  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
     slice.refcount->Ref();
   }
   return slice;
 }
 
 inline void grpc_slice_unref_internal(const grpc_slice& slice) {
-  if (slice.refcount) {
+  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
     slice.refcount->Unref();
   }
 }

data/src/core/lib/slice/slice_refcount_base.h

@@ -23,143 +23,39 @@
 #include <grpc/support/log.h>
 
 // grpc_slice_refcount : A reference count for grpc_slice.
-//
-// Non-inlined grpc_slice objects are refcounted. Historically this was
-// implemented via grpc_slice_refcount, a C-style polymorphic class using a
-// manually managed vtable of operations. Subclasses would define their own
-// vtable; the 'virtual' methods (ref, unref, equals and hash) would simply call
-// the function pointers in the vtable as necessary.
-//
-// Unfortunately, this leads to some inefficiencies in the generated code that
-// can be improved upon. For example, equality checking for interned slices is a
-// simple equality check on the refcount pointer. With the vtable approach, this
-// would translate to roughly the following (high-level) instructions:
-//
-// grpc_slice_equals(slice1, slice2):
-//   load vtable->eq -> eq_func
-//   call eq_func(slice1, slice2)
-//
-// interned_slice_equals(slice1, slice2)
-//   load slice1.ref -> r1
-//   load slice2.ref -> r2
-//   cmp r1, r2 -> retval
-//   ret retval
-//
-// This leads to a function call for a function defined in another translation
-// unit, which imposes memory barriers, which reduces the compiler's ability to
-// optimize (in addition to the added overhead of call/ret). Additionally, it
-// may be harder to reason about branch prediction when we're jumping to
-// essentially arbitrarily provided function pointers.
-//
-// In addition, it is arguable that while virtualization was helpful for
-// Equals()/Hash() methods, that it was fundamentally unnecessary for
-// Ref()/Unref().
-//
-// Instead, grpc_slice_refcount provides the same functionality as the C-style
-// virtual class, but in a de-virtualized manner - Eq(), Hash(), Ref() and
-// Unref() are provided within this header file. Fastpaths for Eq()/Hash()
-// (interned and static metadata slices), as well as the Ref() operation, can
-// all be inlined without any memory barriers.
-//
-// It does this by:
-// 1. Using grpc_core::RefCount<> (header-only) for Ref/Unref. Two special cases
-//    need support: No-op ref/unref (eg. static metadata slices) and stream
-//    slice references (where all the slices share the streamref). This is in
-//    addition to the normal case of '1 slice, 1 ref'.
-//    To support these cases, we explicitly track a nullable pointer to the
-//    underlying RefCount<>. No-op ref/unref is used by checking the pointer for
-//    null, and doing nothing if it is. Both stream slice refs and 'normal'
-//    slices use the same path for Ref/Unref (by targeting the non-null
-//    pointer).
-//
-// 2. introducing the notion of grpc_slice_refcount::Type. This describes if a
-//    slice ref is used by a static metadata slice, an interned slice, or other
-//    slices. We switch on the slice ref type in order to provide fastpaths for
-//    Equals() and Hash().
-//
-// In total, this saves us roughly 1-2% latency for unary calls, with smaller
-// calls benefitting. The effect is present, but not as useful, for larger calls
-// where the cost of sending the data dominates.
-// TODO(arjunroy): Investigate if this can be removed with strongly typed
-// grpc_slices.
 struct grpc_slice_refcount {
  public:
-  enum class Type {
-    INTERNED,  // Refcount for an interned slice.
-    NOP,       // No-Op
-    REGULAR    // Refcount for non-static-metadata, non-interned slices.
-  };
-  typedef void (*DestroyerFn)(void*);
+  typedef void (*DestroyerFn)(grpc_slice_refcount*);
 
-  grpc_slice_refcount() = default;
+  static grpc_slice_refcount* NoopRefcount() {
+    return reinterpret_cast<grpc_slice_refcount*>(1);
+  }
 
-  explicit grpc_slice_refcount(Type t) : ref_type_(t) {}
+  grpc_slice_refcount() = default;
 
-  explicit grpc_slice_refcount(grpc_slice_refcount* sub) : sub_refcount_(sub) {}
   // Regular constructor for grpc_slice_refcount.
   //
   // Parameters:
-  //  1. grpc_slice_refcount::Type type
-  //  Whether we are the refcount for a static
-  //  metadata slice, an interned slice, or any other kind of slice.
-  //
-  //  2. std::atomic<size_t>* ref
-  //  The pointer to the actual underlying grpc_core::RefCount.
-  //  TODO(ctiller): remove the pointer indirection and just put the refcount on
-  //  this object once we remove interning.
-  //
-  //  3. DestroyerFn destroyer_fn
-  //  Called when the refcount goes to 0, with destroyer_arg as parameter.
-  //
-  //  4. void* destroyer_arg
-  //  Argument for the virtualized destructor.
-  //
-  //  5. grpc_slice_refcount* sub
-  //  Argument used for interned slices.
-  grpc_slice_refcount(grpc_slice_refcount::Type type, std::atomic<size_t>* ref,
-                      DestroyerFn destroyer_fn, void* destroyer_arg,
-                      grpc_slice_refcount* sub)
-      : ref_(ref),
-        ref_type_(type),
-        sub_refcount_(sub),
-        dest_fn_(destroyer_fn),
-        destroy_fn_arg_(destroyer_arg) {}
-  // Initializer for static refcounts.
-  grpc_slice_refcount(grpc_slice_refcount* sub, Type type)
-      : ref_type_(type), sub_refcount_(sub) {}
+  //  1. DestroyerFn destroyer_fn
+  //  Called when the refcount goes to 0, with 'this' as parameter.
+  explicit grpc_slice_refcount(DestroyerFn destroyer_fn)
+      : destroyer_fn_(destroyer_fn) {}
 
-  Type GetType() const { return ref_type_; }
-
-  int Eq(const grpc_slice& a, const grpc_slice& b);
-
-  uint32_t Hash(const grpc_slice& slice);
-  void Ref() {
-    if (ref_ == nullptr) return;
-    ref_->fetch_add(1, std::memory_order_relaxed);
-  }
+  void Ref() { ref_.fetch_add(1, std::memory_order_relaxed); }
   void Unref() {
-    if (ref_ == nullptr) return;
-    if (ref_->fetch_sub(1, std::memory_order_acq_rel) == 1) {
-      dest_fn_(destroy_fn_arg_);
+    if (ref_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+      destroyer_fn_(this);
     }
   }
 
-  // Only for type REGULAR, is this the only instance?
+  // Is this the only instance?
   // For this to be useful the caller needs to ensure that if this is the only
   // instance, no other instance could be created during this call.
-  bool IsRegularUnique() {
-    GPR_DEBUG_ASSERT(ref_type_ == Type::REGULAR);
-    return ref_->load(std::memory_order_relaxed) == 1;
-  }
-
-  grpc_slice_refcount* sub_refcount() const { return sub_refcount_; }
+  bool IsUnique() const { return ref_.load(std::memory_order_relaxed) == 1; }
 
  private:
-  std::atomic<size_t>* ref_ = nullptr;
-  const Type ref_type_ = Type::REGULAR;
-  grpc_slice_refcount* sub_refcount_ = this;
-  DestroyerFn dest_fn_ = nullptr;
-  void* destroy_fn_arg_ = nullptr;
+  std::atomic<size_t> ref_{1};
+  DestroyerFn destroyer_fn_ = nullptr;
 };
 
 #endif  // GRPC_CORE_LIB_SLICE_SLICE_REFCOUNT_BASE_H

data/src/core/lib/surface/builtins.cc

@@ -35,14 +35,14 @@ void RegisterBuiltins(CoreConfiguration::Builder* builder) {
                                          grpc_add_connected_filter);
   builder->channel_init()->RegisterStage(
       GRPC_CLIENT_LAME_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](grpc_channel_stack_builder* builder) {
-        return grpc_channel_stack_builder_append_filter(
-            builder, &grpc_lame_filter, nullptr, nullptr);
+      [](ChannelStackBuilder* builder) {
+        builder->AppendFilter(&grpc_lame_filter, nullptr);
+        return true;
       });
   builder->channel_init()->RegisterStage(
-      GRPC_SERVER_CHANNEL, INT_MAX, [](grpc_channel_stack_builder* builder) {
-        return grpc_channel_stack_builder_prepend_filter(
-            builder, &Server::kServerTopFilter, nullptr, nullptr);
+      GRPC_SERVER_CHANNEL, INT_MAX, [](ChannelStackBuilder* builder) {
+        builder->PrependFilter(&Server::kServerTopFilter, nullptr);
+        return true;
       });
 }
 

data/src/core/lib/surface/call.cc

@@ -50,9 +50,9 @@
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_split.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call_test_only.h"
 #include "src/core/lib/surface/channel.h"
@@ -208,7 +208,7 @@ struct grpc_call {
   /* Contexts for various subsystems (security, tracing, ...). */
   grpc_call_context_element context[GRPC_CONTEXT_COUNT] = {};
 
-  grpc_millis send_deadline;
+  grpc_core::Timestamp send_deadline;
 
   grpc_core::ManualConstructor<grpc_core::SliceBufferByteStream> sending_stream;
 
@@ -298,6 +298,7 @@ static void add_init_error(grpc_error_handle* composite,
 }
 
 void* grpc_call_arena_alloc(grpc_call* call, size_t size) {
+  grpc_core::ExecCtx exec_ctx;
   return call->arena->Alloc(size);
 }
 
@@ -370,7 +371,7 @@ grpc_error_handle grpc_call_create(grpc_call_create_args* args,
     call->final_op.server.core_server = args->server;
   }
 
-  grpc_millis send_deadline = args->send_deadline;
+  grpc_core::Timestamp send_deadline = args->send_deadline;
   bool immediately_cancel = false;
 
   if (args->parent != nullptr) {
@@ -830,8 +831,9 @@ class PublishToAppEncoder {
     Append(grpc_core::GrpcPreviousRpcAttemptsMetadata::key(), count);
   }
 
-  void Encode(grpc_core::GrpcRetryPushbackMsMetadata, grpc_millis count) {
-    Append(grpc_core::GrpcRetryPushbackMsMetadata::key(), count);
+  void Encode(grpc_core::GrpcRetryPushbackMsMetadata,
+              grpc_core::Duration count) {
+    Append(grpc_core::GrpcRetryPushbackMsMetadata::key(), count.millis());
   }
 
   void Encode(grpc_core::LbTokenMetadata, const grpc_core::Slice& slice) {
@@ -1257,7 +1259,7 @@ static void receiving_initial_metadata_ready(void* bctlp,
     GPR_TIMER_SCOPE("validate_filtered_metadata", 0);
     validate_filtered_metadata(bctl);
 
-    absl::optional<grpc_millis> deadline =
+    absl::optional<grpc_core::Timestamp> deadline =
         md->get(grpc_core::GrpcTimeoutMetadata());
     if (deadline.has_value() && !call->is_client) {
       call->send_deadline = *deadline;
@@ -1440,8 +1442,11 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
           error = GRPC_CALL_ERROR_INVALID_METADATA;
           goto done_with_error;
         }
+        // Ignore any te metadata key value pairs specified.
+        call->send_initial_metadata.Remove(grpc_core::TeMetadata());
         /* TODO(ctiller): just make these the same variable? */
-        if (call->is_client && call->send_deadline != GRPC_MILLIS_INF_FUTURE) {
+        if (call->is_client &&
+            call->send_deadline != grpc_core::Timestamp::InfFuture()) {
           call->send_initial_metadata.Set(grpc_core::GrpcTimeoutMetadata(),
                                           call->send_deadline);
         }
@@ -1567,6 +1572,8 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
             grpc_core::GrpcStatusMetadata(),
             op->data.send_status_from_server.status);
 
+        // Ignore any te metadata key value pairs specified.
+        call->send_trailing_metadata.Remove(grpc_core::TeMetadata());
         stream_op_payload->send_trailing_metadata.send_trailing_metadata =
             &call->send_trailing_metadata;
         stream_op_payload->send_trailing_metadata.sent =

data/src/core/lib/surface/call.h

@@ -49,7 +49,7 @@ typedef struct grpc_call_create_args {
   absl::optional<grpc_core::Slice> path;
   absl::optional<grpc_core::Slice> authority;
 
-  grpc_millis send_deadline;
+  grpc_core::Timestamp send_deadline;
 } grpc_call_create_args;
 
 /* Create a new call based on \a args.

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

@@ -58,21 +58,20 @@
 static void destroy_channel(void* arg, grpc_error_handle error);
 
 grpc_channel* grpc_channel_create_with_builder(
-    grpc_channel_stack_builder* builder,
+    grpc_core::ChannelStackBuilder* builder,
     grpc_channel_stack_type channel_stack_type, grpc_error_handle* error) {
-  std::string target = grpc_channel_stack_builder_get_target(builder);
-  grpc_channel_args* args = grpc_channel_args_copy(
-      grpc_channel_stack_builder_get_channel_arguments(builder));
+  std::string target(builder->target());
+  grpc_channel_args* args = grpc_channel_args_copy(builder->channel_args());
   grpc_channel* channel;
   if (channel_stack_type == GRPC_SERVER_CHANNEL) {
     GRPC_STATS_INC_SERVER_CHANNELS_CREATED();
   } else {
     GRPC_STATS_INC_CLIENT_CHANNELS_CREATED();
   }
-  std::string name = grpc_channel_stack_builder_get_target(builder);
-  grpc_error_handle builder_error = grpc_channel_stack_builder_finish(
-      builder, sizeof(grpc_channel), 1, destroy_channel, nullptr,
-      reinterpret_cast<void**>(&channel));
+  std::string name(builder->target());
+  grpc_error_handle builder_error =
+      builder->Build(sizeof(grpc_channel), 1, destroy_channel, nullptr,
+                     reinterpret_cast<void**>(&channel));
   if (builder_error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "channel stack builder failed: %s",
             grpc_error_std_string(builder_error).c_str());
@@ -187,9 +186,8 @@ int channelz_node_cmp(void* p1, void* p2) {
 const grpc_arg_pointer_vtable channelz_node_arg_vtable = {
     channelz_node_copy, channelz_node_destroy, channelz_node_cmp};
 
-void CreateChannelzNode(grpc_channel_stack_builder* builder) {
-  const grpc_channel_args* args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
+void CreateChannelzNode(grpc_core::ChannelStackBuilder* builder) {
+  const grpc_channel_args* args = builder->channel_args();
   // Check whether channelz is enabled.
   const bool channelz_enabled = grpc_channel_args_find_bool(
       args, GRPC_ARG_ENABLE_CHANNELZ, GRPC_ENABLE_CHANNELZ_DEFAULT);
@@ -201,7 +199,7 @@ void CreateChannelzNode(grpc_channel_stack_builder* builder) {
   const bool is_internal_channel = grpc_channel_args_find_bool(
       args, GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, false);
   // Create the channelz node.
-  std::string target = grpc_channel_stack_builder_get_target(builder);
+  std::string target(builder->target());
   grpc_core::RefCountedPtr<grpc_core::channelz::ChannelNode> channelz_node =
       grpc_core::MakeRefCounted<grpc_core::channelz::ChannelNode>(
           target.c_str(), channel_tracer_max_memory, is_internal_channel);
@@ -216,17 +214,16 @@ void CreateChannelzNode(grpc_channel_stack_builder* builder) {
   const char* args_to_remove[] = {GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL};
   grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
       args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove), &new_arg, 1);
-  grpc_channel_stack_builder_set_channel_arguments(builder, new_args);
+  builder->SetChannelArgs(new_args);
   grpc_channel_args_destroy(new_args);
 }
 
 }  // namespace
 
-grpc_channel* grpc_channel_create(const char* target,
-                                  const grpc_channel_args* input_args,
-                                  grpc_channel_stack_type channel_stack_type,
-                                  grpc_transport* optional_transport,
-                                  grpc_error_handle* error) {
+grpc_channel* grpc_channel_create_internal(
+    const char* target, const grpc_channel_args* input_args,
+    grpc_channel_stack_type channel_stack_type,
+    grpc_transport* optional_transport, grpc_error_handle* error) {
   // We need to make sure that grpc_shutdown() does not shut things down
   // until after the channel is destroyed.  However, the channel may not
   // actually be destroyed by the time grpc_channel_destroy() returns,
@@ -244,7 +241,7 @@ grpc_channel* grpc_channel_create(const char* target,
   // grpc_shutdown() when the channel is actually destroyed, thus
   // ensuring that shutdown is deferred until that point.
   grpc_init();
-  grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create(
+  grpc_core::ChannelStackBuilder builder(
       grpc_channel_stack_type_string(channel_stack_type));
   const grpc_core::UniquePtr<char> default_authority =
       get_default_authority(input_args);
@@ -257,23 +254,21 @@ grpc_channel* grpc_channel_create(const char* target,
       args = channel_args_mutator(target, args, channel_stack_type);
     }
   }
-  grpc_channel_stack_builder_set_channel_arguments(builder, args);
+  builder.SetChannelArgs(args).SetTarget(target).SetTransport(
+      optional_transport);
   grpc_channel_args_destroy(args);
-  grpc_channel_stack_builder_set_target(builder, target);
-  grpc_channel_stack_builder_set_transport(builder, optional_transport);
   if (!grpc_core::CoreConfiguration::Get().channel_init().CreateStack(
-          builder, channel_stack_type)) {
-    grpc_channel_stack_builder_destroy(builder);
+          &builder, channel_stack_type)) {
     grpc_shutdown();  // Since we won't call destroy_channel().
     return nullptr;
   }
   // We only need to do this for clients here. For servers, this will be
   // done in src/core/lib/surface/server.cc.
   if (grpc_channel_stack_type_is_client(channel_stack_type)) {
-    CreateChannelzNode(builder);
+    CreateChannelzNode(&builder);
   }
   grpc_channel* channel =
-      grpc_channel_create_with_builder(builder, channel_stack_type, error);
+      grpc_channel_create_with_builder(&builder, channel_stack_type, error);
   if (channel == nullptr) {
     grpc_shutdown();  // Since we won't call destroy_channel().
   }
@@ -345,7 +340,7 @@ static grpc_call* grpc_channel_create_call_internal(
     grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
     grpc_core::Slice path, absl::optional<grpc_core::Slice> authority,
-    grpc_millis deadline) {
+    grpc_core::Timestamp deadline) {
   GPR_ASSERT(channel->is_client);
   GPR_ASSERT(!(cq != nullptr && pollset_set_alternative != nullptr));
 
@@ -381,7 +376,7 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
       host != nullptr
           ? absl::optional<grpc_core::Slice>(grpc_slice_ref_internal(*host))
           : absl::nullopt,
-      grpc_timespec_to_millis_round_up(deadline));
+      grpc_core::Timestamp::FromTimespecRoundUp(deadline));
 
   return call;
 }
@@ -389,7 +384,7 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
 grpc_call* grpc_channel_create_pollset_set_call(
     grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
     grpc_pollset_set* pollset_set, const grpc_slice& method,
-    const grpc_slice* host, grpc_millis deadline, void* reserved) {
+    const grpc_slice* host, grpc_core::Timestamp deadline, void* reserved) {
   GPR_ASSERT(!reserved);
   return grpc_channel_create_call_internal(
       channel, parent_call, propagation_mask, nullptr, pollset_set,
@@ -468,7 +463,7 @@ grpc_call* grpc_channel_create_registered_call(
       rc->authority.has_value()
           ? absl::optional<grpc_core::Slice>(rc->authority->Ref())
           : absl::nullopt,
-      grpc_timespec_to_millis_round_up(deadline));
+      grpc_core::Timestamp::FromTimespecRoundUp(deadline));
 
   return call;
 }
@@ -486,7 +481,7 @@ static void destroy_channel(void* arg, grpc_error_handle /*error*/) {
   channel->allocator.Destroy();
   channel->target.Destroy();
   gpr_free(channel);
-  // See comment in grpc_channel_create() for why we do this.
+  // See comment in grpc_channel_create_internal() for why we do this.
   grpc_shutdown();
 }
 

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

@@ -31,11 +31,10 @@
 #include "src/core/lib/surface/channel_stack_type.h"
 
 /// Creates a grpc_channel.
-grpc_channel* grpc_channel_create(const char* target,
-                                  const grpc_channel_args* args,
-                                  grpc_channel_stack_type channel_stack_type,
-                                  grpc_transport* optional_transport,
-                                  grpc_error_handle* error);
+grpc_channel* grpc_channel_create_internal(
+    const char* target, const grpc_channel_args* args,
+    grpc_channel_stack_type channel_stack_type,
+    grpc_transport* optional_transport, grpc_error_handle* error);
 
 /** The same as grpc_channel_destroy, but doesn't create an ExecCtx, and so
  * is safe to use from within core. */
@@ -44,7 +43,7 @@ void grpc_channel_destroy_internal(grpc_channel* channel);
 /// Creates a grpc_channel with a builder. See the description of
 /// \a grpc_channel_create for variable definitions.
 grpc_channel* grpc_channel_create_with_builder(
-    grpc_channel_stack_builder* builder,
+    grpc_core::ChannelStackBuilder* builder,
     grpc_channel_stack_type channel_stack_type,
     grpc_error_handle* error = nullptr);
 
@@ -59,7 +58,7 @@ grpc_channel* grpc_channel_create_with_builder(
 grpc_call* grpc_channel_create_pollset_set_call(
     grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
     grpc_pollset_set* pollset_set, const grpc_slice& method,
-    const grpc_slice* host, grpc_millis deadline, void* reserved);
+    const grpc_slice* host, grpc_core::Timestamp deadline, void* reserved);
 
 /** Get a (borrowed) pointer to this channels underlying channel stack */
 grpc_channel_stack* grpc_channel_get_channel_stack(grpc_channel* channel);

data/src/core/lib/surface/channel_init.cc

@@ -45,7 +45,7 @@ ChannelInit ChannelInit::Builder::Build() {
   return result;
 }
 
-bool ChannelInit::CreateStack(grpc_channel_stack_builder* builder,
+bool ChannelInit::CreateStack(ChannelStackBuilder* builder,
                               grpc_channel_stack_type type) const {
   for (const auto& stage : slots_[type]) {
     if (!stage(builder)) return false;

data/src/core/lib/surface/channel_init.h

@@ -33,15 +33,15 @@
 /// It also provides a universal entry path to run those mutators to build
 /// a channel stack for various subsystems.
 
-typedef struct grpc_channel_stack_builder grpc_channel_stack_builder;
-
 namespace grpc_core {
 
+class ChannelStackBuilder;
+
 class ChannelInit {
  public:
   /// One stage of mutation: call functions against \a builder to influence the
   /// finally constructed channel stack
-  using Stage = std::function<bool(grpc_channel_stack_builder* builder)>;
+  using Stage = std::function<bool(ChannelStackBuilder* builder)>;
 
   class Builder {
    public:
@@ -74,7 +74,7 @@ class ChannelInit {
   /// Construct a channel stack of some sort: see channel_stack.h for details
   /// \a type is the type of channel stack to create
   /// \a builder is the channel stack builder to build into.
-  bool CreateStack(grpc_channel_stack_builder* builder,
+  bool CreateStack(ChannelStackBuilder* builder,
                    grpc_channel_stack_type type) const;
 
  private: