grpc 1.60.0 → 1.62.0

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

@@ -77,34 +77,35 @@ typedef struct grpc_call_create_args {
 } grpc_call_create_args;
 
 namespace grpc_core {
-class PromiseBasedCall;
+class BasicPromiseBasedCall;
 class ServerPromiseBasedCall;
 
 class ServerCallContext {
  public:
-  ServerCallContext(ServerPromiseBasedCall* call,
-                    const void* server_stream_data)
-      : call_(call), server_stream_data_(server_stream_data) {}
-  ArenaPromise<ServerMetadataHandle> MakeTopOfServerCallPromise(
+  virtual void PublishInitialMetadata(
+      ClientMetadataHandle metadata,
+      grpc_metadata_array* publish_initial_metadata) = 0;
+
+  // Construct the top of the server call promise for the v2 filter stack.
+  // TODO(ctiller): delete when v3 is available.
+  virtual ArenaPromise<ServerMetadataHandle> MakeTopOfServerCallPromise(
       CallArgs call_args, grpc_completion_queue* cq,
-      grpc_metadata_array* publish_initial_metadata,
-      absl::FunctionRef<void(grpc_call* call)> publish);
+      absl::FunctionRef<void(grpc_call* call)> publish) = 0;
 
   // Server stream data as supplied by the transport (so we can link the
   // transport stream up with the call again).
   // TODO(ctiller): legacy API - once we move transports to promises we'll
   // create the promise directly and not need to pass around this token.
-  const void* server_stream_data() { return server_stream_data_; }
+  virtual const void* server_stream_data() = 0;
 
- private:
-  ServerPromiseBasedCall* const call_;
-  const void* const server_stream_data_;
+ protected:
+  ~ServerCallContext() = default;
 };
 
 // TODO(ctiller): move more call things into this type
 class CallContext {
  public:
-  explicit CallContext(PromiseBasedCall* call) : call_(call) {}
+  explicit CallContext(BasicPromiseBasedCall* call) : call_(call) {}
 
   // Update the deadline (if deadline < the current deadline).
   void UpdateDeadline(Timestamp deadline);
@@ -135,13 +136,21 @@ class CallContext {
   void set_traced(bool traced) { traced_ = traced; }
   bool traced() const { return traced_; }
 
+  // TEMPORARY HACK
+  // Create a call spine object for this call.
+  // Said object should only be created once.
+  // Allows interop between the v2 call stack and the v3 (which is required by
+  // transports).
+  RefCountedPtr<CallSpineInterface> MakeCallSpine(CallArgs call_args);
+  grpc_call* c_call();
+
  private:
   friend class PromiseBasedCall;
   // Call final info.
   grpc_call_stats call_stats_;
   // TODO(ctiller): remove this once transport APIs are promise based and we
   // don't need refcounting here.
-  PromiseBasedCall* const call_;
+  BasicPromiseBasedCall* const call_;
   gpr_cycle_counter start_time_ = gpr_get_cycle_counter();
   // Is this call traced?
   bool traced_ = false;
@@ -150,6 +159,10 @@ class CallContext {
 template <>
 struct ContextType<CallContext> {};
 
+RefCountedPtr<CallSpineInterface> MakeServerCall(Server* server,
+                                                 Channel* channel,
+                                                 Arena* arena);
+
 }  // namespace grpc_core
 
 // Create a new call based on \a args.

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

@@ -56,28 +56,69 @@ const grpc_channel_filter* PromiseTracingFilterFor(
                 gpr_log(
                     GPR_DEBUG,
                     "%s[%s] CreateCallPromise: client_initial_metadata=%s",
-                    Activity::current()->DebugTag().c_str(),
+                    GetContext<Activity>()->DebugTag().c_str(),
                     source_filter->name,
                     call_args.client_initial_metadata->DebugString().c_str());
                 return [source_filter, child = next_promise_factory(
                                            std::move(call_args))]() mutable {
                   gpr_log(GPR_DEBUG, "%s[%s] PollCallPromise: begin",
-                          Activity::current()->DebugTag().c_str(),
+                          GetContext<Activity>()->DebugTag().c_str(),
                           source_filter->name);
                   auto r = child();
                   if (auto* p = r.value_if_ready()) {
                     gpr_log(GPR_DEBUG, "%s[%s] PollCallPromise: done: %s",
-                            Activity::current()->DebugTag().c_str(),
+                            GetContext<Activity>()->DebugTag().c_str(),
                             source_filter->name, (*p)->DebugString().c_str());
                   } else {
                     gpr_log(GPR_DEBUG, "%s[%s] PollCallPromise: <<pending>>",
-                            Activity::current()->DebugTag().c_str(),
+                            GetContext<Activity>()->DebugTag().c_str(),
                             source_filter->name);
                   }
                   return r;
                 };
               },
-              grpc_channel_next_op, /* sizeof_call_data: */ 0,
+              /* init_call: */
+              [](grpc_channel_element* elem, CallSpineInterface* call) {
+                auto* source_filter =
+                    static_cast<const DerivedFilter*>(elem->filter)->filter;
+                call->client_initial_metadata().receiver.InterceptAndMap(
+                    [source_filter](ClientMetadataHandle md) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnClientInitialMetadata: %s",
+                              GetContext<Activity>()->DebugTag().c_str(),
+                              source_filter->name, md->DebugString().c_str());
+                      return md;
+                    });
+                call->client_to_server_messages().receiver.InterceptAndMap(
+                    [source_filter](MessageHandle msg) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnClientToServerMessage: %s",
+                              GetContext<Activity>()->DebugTag().c_str(),
+                              source_filter->name, msg->DebugString().c_str());
+                      return msg;
+                    });
+                call->server_initial_metadata().sender.InterceptAndMap(
+                    [source_filter](ServerMetadataHandle md) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnServerInitialMetadata: %s",
+                              GetContext<Activity>()->DebugTag().c_str(),
+                              source_filter->name, md->DebugString().c_str());
+                      return md;
+                    });
+                call->server_to_client_messages().sender.InterceptAndMap(
+                    [source_filter](MessageHandle msg) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnServerToClientMessage: %s",
+                              GetContext<Activity>()->DebugTag().c_str(),
+                              source_filter->name, msg->DebugString().c_str());
+                      return msg;
+                    });
+                call->server_trailing_metadata().sender.InterceptAndMap(
+                    [source_filter](ServerMetadataHandle md) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnServerTrailingMetadata: %s",
+                              GetContext<Activity>()->DebugTag().c_str(),
+                              source_filter->name, md->DebugString().c_str());
+                      return md;
+                    });
+              },
+              grpc_channel_next_op,
+              /* sizeof_call_data: */ 0,
               // init_call_elem:
               [](grpc_call_element*, const grpc_call_element_args*) {
                 return absl::OkStatus();

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

@@ -58,12 +58,25 @@
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/init_internally.h"
+#include "src/core/lib/transport/call_factory.h"
 #include "src/core/lib/transport/transport.h"
 
 // IWYU pragma: no_include <type_traits>
 
 namespace grpc_core {
 
+namespace {
+
+class NotReallyACallFactory final : public CallFactory {
+ public:
+  using CallFactory::CallFactory;
+  CallInitiator CreateCall(ClientMetadataHandle, Arena*) override {
+    Crash("NotReallyACallFactory::CreateCall should never be called");
+  }
+};
+
+}  // namespace
+
 Channel::Channel(bool is_client, bool is_promising, std::string target,
                  const ChannelArgs& channel_args,
                  grpc_compression_options compression_options,
@@ -71,14 +84,10 @@ Channel::Channel(bool is_client, bool is_promising, std::string target,
     : is_client_(is_client),
       is_promising_(is_promising),
       compression_options_(compression_options),
-      call_size_estimate_(channel_stack->call_stack_size +
-                          grpc_call_get_initial_size_estimate()),
       channelz_node_(channel_args.GetObjectRef<channelz::ChannelNode>()),
-      allocator_(channel_args.GetObject<ResourceQuota>()
-                     ->memory_quota()
-                     ->CreateMemoryOwner()),
       target_(std::move(target)),
-      channel_stack_(std::move(channel_stack)) {
+      channel_stack_(std::move(channel_stack)),
+      call_factory_(MakeRefCounted<NotReallyACallFactory>(channel_args)) {
   // 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,
@@ -230,24 +239,6 @@ absl::StatusOr<RefCountedPtr<Channel>> Channel::Create(
   return CreateWithBuilder(&builder);
 }
 
-void Channel::UpdateCallSizeEstimate(size_t size) {
-  size_t cur = call_size_estimate_.load(std::memory_order_relaxed);
-  if (cur < size) {
-    // size grew: update estimate
-    call_size_estimate_.compare_exchange_weak(
-        cur, size, std::memory_order_relaxed, std::memory_order_relaxed);
-    // if we lose: never mind, something else will likely update soon enough
-  } else if (cur == size) {
-    // no change: holding pattern
-  } else if (cur > 0) {
-    // size shrank: decrease estimate
-    call_size_estimate_.compare_exchange_weak(
-        cur, std::min(cur - 1, (255 * cur + size) / 256),
-        std::memory_order_relaxed, std::memory_order_relaxed);
-    // if we lose: never mind, something else will likely update soon enough
-  }
-}
-
 }  // namespace grpc_core
 
 char* grpc_channel_get_target(grpc_channel* channel) {
@@ -376,7 +367,6 @@ namespace grpc_core {
 
 RegisteredCall* Channel::RegisterCall(const char* method, const char* host) {
   MutexLock lock(&registration_table_.mu);
-  registration_table_.method_registration_attempts++;
   auto key = std::make_pair(std::string(host != nullptr ? host : ""),
                             std::string(method != nullptr ? method : ""));
   auto rc_posn = registration_table_.map.find(key);

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

@@ -52,9 +52,9 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/call_factory.h"
 #include "src/core/lib/transport/transport.h"
 
 /// The same as grpc_channel_destroy, but doesn't create an ExecCtx, and so
@@ -80,9 +80,6 @@ grpc_channel_stack* grpc_channel_get_channel_stack(grpc_channel* channel);
 grpc_core::channelz::ChannelNode* grpc_channel_get_channelz_node(
     grpc_channel* channel);
 
-size_t grpc_channel_get_call_size_estimate(grpc_channel* channel);
-void grpc_channel_update_call_size_estimate(grpc_channel* channel, size_t size);
-
 namespace grpc_core {
 
 struct RegisteredCall {
@@ -103,7 +100,6 @@ struct CallRegistrationTable {
   // C++ or other wrapped language Channel that registered these calls).
   std::map<std::pair<std::string, std::string>, RegisteredCall> map
       ABSL_GUARDED_BY(mu);
-  int method_registration_attempts ABSL_GUARDED_BY(mu) = 0;
 };
 
 class Channel : public RefCounted<Channel>,
@@ -125,22 +121,10 @@ class Channel : public RefCounted<Channel>,
 
   channelz::ChannelNode* channelz_node() const { return channelz_node_.get(); }
 
-  size_t CallSizeEstimate() {
-    // We round up our current estimate to the NEXT value of kRoundUpSize.
-    // This ensures:
-    //  1. a consistent size allocation when our estimate is drifting slowly
-    //     (which is common) - which tends to help most allocators reuse memory
-    //  2. a small amount of allowed growth over the estimate without hitting
-    //     the arena size doubling case, reducing overall memory usage
-    static constexpr size_t kRoundUpSize = 256;
-    return (call_size_estimate_.load(std::memory_order_relaxed) +
-            2 * kRoundUpSize) &
-           ~(kRoundUpSize - 1);
-  }
+  Arena* CreateArena() { return call_factory_->CreateArena(); }
+  void DestroyArena(Arena* arena) { return call_factory_->DestroyArena(arena); }
 
-  void UpdateCallSizeEstimate(size_t size);
   absl::string_view target() const { return target_; }
-  MemoryAllocator* allocator() { return &allocator_; }
   bool is_client() const { return is_client_; }
   bool is_promising() const { return is_promising_; }
   RegisteredCall* RegisterCall(const char* method, const char* host);
@@ -150,11 +134,6 @@ class Channel : public RefCounted<Channel>,
     return registration_table_.map.size();
   }
 
-  int TestOnlyRegistrationAttempts() {
-    MutexLock lock(&registration_table_.mu);
-    return registration_table_.method_registration_attempts;
-  }
-
   grpc_event_engine::experimental::EventEngine* event_engine() const {
     return channel_stack_->EventEngine();
   }
@@ -168,12 +147,11 @@ class Channel : public RefCounted<Channel>,
   const bool is_client_;
   const bool is_promising_;
   const grpc_compression_options compression_options_;
-  std::atomic<size_t> call_size_estimate_;
   CallRegistrationTable registration_table_;
   RefCountedPtr<channelz::ChannelNode> channelz_node_;
-  MemoryAllocator allocator_;
   std::string target_;
   const RefCountedPtr<grpc_channel_stack> channel_stack_;
+  const RefCountedPtr<CallFactory> call_factory_;
 };
 
 }  // namespace grpc_core

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

@@ -104,9 +104,9 @@ ChannelInit::FilterRegistration::ExcludeFromMinimalStack() {
 
 ChannelInit::FilterRegistration& ChannelInit::Builder::RegisterFilter(
     grpc_channel_stack_type type, const grpc_channel_filter* filter,
-    SourceLocation registration_source) {
-  filters_[type].emplace_back(
-      std::make_unique<FilterRegistration>(filter, registration_source));
+    const ChannelFilterVtable* vtable, SourceLocation registration_source) {
+  filters_[type].emplace_back(std::make_unique<FilterRegistration>(
+      filter, vtable, registration_source));
   return *filters_[type].back();
 }
 
@@ -141,7 +141,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
       GPR_ASSERT(registration->after_.empty());
       GPR_ASSERT(registration->before_.empty());
       GPR_ASSERT(!registration->before_all_);
-      terminal_filters.emplace_back(registration->filter_,
+      terminal_filters.emplace_back(registration->filter_, nullptr,
                                     std::move(registration->predicates_),
                                     registration->registration_source_);
     } else {
@@ -222,9 +222,10 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
   std::vector<Filter> filters;
   while (!dependencies.empty()) {
     auto filter = take_ready_dependency();
-    filters.emplace_back(filter,
-                         std::move(filter_to_registration[filter]->predicates_),
-                         filter_to_registration[filter]->registration_source_);
+    auto* registration = filter_to_registration[filter];
+    filters.emplace_back(filter, registration->vtable_,
+                         std::move(registration->predicates_),
+                         registration->registration_source_);
     for (auto& p : dependencies) {
       p.second.erase(filter);
     }
@@ -405,4 +406,77 @@ bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
   return true;
 }
 
+absl::StatusOr<ChannelInit::StackSegment> ChannelInit::CreateStackSegment(
+    grpc_channel_stack_type type, const ChannelArgs& args) const {
+  const auto& stack_config = stack_configs_[type];
+  std::vector<StackSegment::ChannelFilter> filters;
+  size_t channel_data_size = 0;
+  size_t channel_data_alignment = 0;
+  // Based on predicates build a list of filters to include in this segment.
+  for (const auto& filter : stack_config.filters) {
+    if (!filter.CheckPredicates(args)) continue;
+    if (filter.vtable == nullptr) {
+      return absl::InvalidArgumentError(
+          absl::StrCat("Filter ", NameFromChannelFilter(filter.filter),
+                       " has no v3-callstack vtable"));
+    }
+    channel_data_alignment =
+        std::max(channel_data_alignment, filter.vtable->alignment);
+    if (channel_data_size % filter.vtable->alignment != 0) {
+      channel_data_size += filter.vtable->alignment -
+                           (channel_data_size % filter.vtable->alignment);
+    }
+    filters.push_back({channel_data_size, filter.vtable});
+    channel_data_size += filter.vtable->size;
+  }
+  // Shortcut for empty segments.
+  if (filters.empty()) return StackSegment();
+  // Allocate memory for the channel data, initialize channel filters into it.
+  uint8_t* p = static_cast<uint8_t*>(
+      gpr_malloc_aligned(channel_data_size, channel_data_alignment));
+  for (size_t i = 0; i < filters.size(); i++) {
+    auto r = filters[i].vtable->init(p + filters[i].offset, args);
+    if (!r.ok()) {
+      for (size_t j = 0; j < i; j++) {
+        filters[j].vtable->destroy(p + filters[j].offset);
+      }
+      gpr_free_aligned(p);
+      return r;
+    }
+  }
+  return StackSegment(std::move(filters), p);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ChannelInit::StackSegment
+
+ChannelInit::StackSegment::StackSegment(std::vector<ChannelFilter> filters,
+                                        uint8_t* channel_data)
+    : data_(MakeRefCounted<ChannelData>(std::move(filters), channel_data)) {}
+
+void ChannelInit::StackSegment::AddToCallFilterStack(
+    CallFilters::StackBuilder& builder) {
+  if (data_ == nullptr) return;
+  data_->AddToCallFilterStack(builder);
+  builder.AddOwnedObject(data_);
+};
+
+ChannelInit::StackSegment::ChannelData::ChannelData(
+    std::vector<ChannelFilter> filters, uint8_t* channel_data)
+    : filters_(std::move(filters)), channel_data_(channel_data) {}
+
+void ChannelInit::StackSegment::ChannelData::AddToCallFilterStack(
+    CallFilters::StackBuilder& builder) {
+  for (const auto& filter : filters_) {
+    filter.vtable->add_to_stack_builder(channel_data_ + filter.offset, builder);
+  }
+}
+
+ChannelInit::StackSegment::ChannelData::~ChannelData() {
+  for (const auto& filter : filters_) {
+    filter.vtable->destroy(channel_data_ + filter.offset);
+  }
+  gpr_free_aligned(channel_data_);
+}
+
 }  // namespace grpc_core

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

@@ -37,6 +37,7 @@
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/call_filters.h"
 
 /// This module provides a way for plugins (and the grpc core library itself)
 /// to register mutators for channel stacks.
@@ -76,22 +77,56 @@ class ChannelInit {
     kCount
   };
 
+  // Vtable-like data structure for channel data initialization
+  struct ChannelFilterVtable {
+    size_t size;
+    size_t alignment;
+    absl::Status (*init)(void* data, const ChannelArgs& args);
+    void (*destroy)(void* data);
+    void (*add_to_stack_builder)(void* data,
+                                 CallFilters::StackBuilder& builder);
+  };
+
   class FilterRegistration {
    public:
+    // TODO(ctiller): Remove grpc_channel_filter* arg when that can be
+    // deprecated (once filter stack is removed).
     explicit FilterRegistration(const grpc_channel_filter* filter,
+                                const ChannelFilterVtable* vtable,
                                 SourceLocation registration_source)
-        : filter_(filter), registration_source_(registration_source) {}
+        : filter_(filter),
+          vtable_(vtable),
+          registration_source_(registration_source) {}
     FilterRegistration(const FilterRegistration&) = delete;
     FilterRegistration& operator=(const FilterRegistration&) = delete;
 
     // Ensure that this filter is placed *after* the filters listed here.
     // By Build() time all filters listed here must also be registered against
     // the same channel stack type as this registration.
+    template <typename Filter>
+    FilterRegistration& After() {
+      return After({&Filter::kFilter});
+    }
+    // Ensure that this filter is placed *before* the filters listed here.
+    // By Build() time all filters listed here must also be registered against
+    // the same channel stack type as this registration.
+    template <typename Filter>
+    FilterRegistration& Before() {
+      return Before({&Filter::kFilter});
+    }
+
+    // Ensure that this filter is placed *after* the filters listed here.
+    // By Build() time all filters listed here must also be registered against
+    // the same channel stack type as this registration.
+    // TODO(ctiller): remove in favor of the version that does not mention
+    // grpc_channel_filter
     FilterRegistration& After(
         std::initializer_list<const grpc_channel_filter*> filters);
     // Ensure that this filter is placed *before* the filters listed here.
     // By Build() time all filters listed here must also be registered against
     // the same channel stack type as this registration.
+    // TODO(ctiller): remove in favor of the version that does not mention
+    // grpc_channel_filter
     FilterRegistration& Before(
         std::initializer_list<const grpc_channel_filter*> filters);
     // Add a predicate for this filters inclusion.
@@ -131,6 +166,7 @@ class ChannelInit {
    private:
     friend class ChannelInit;
     const grpc_channel_filter* const filter_;
+    const ChannelFilterVtable* const vtable_;
     std::vector<const grpc_channel_filter*> after_;
     std::vector<const grpc_channel_filter*> before_;
     std::vector<InclusionPredicate> predicates_;
@@ -145,9 +181,19 @@ class ChannelInit {
     // This occurs first during channel build time.
     // The FilterRegistration methods can be called to declaratively define
     // properties of the filter being registered.
-    FilterRegistration& RegisterFilter(grpc_channel_stack_type type,
-                                       const grpc_channel_filter* filter,
-                                       SourceLocation registration_source = {});
+    // TODO(ctiller): remove in favor of the version that does not mention
+    // grpc_channel_filter
+    FilterRegistration& RegisterFilter(
+        grpc_channel_stack_type type, const grpc_channel_filter* filter,
+        const ChannelFilterVtable* vtable = nullptr,
+        SourceLocation registration_source = {});
+    template <typename Filter>
+    FilterRegistration& RegisterFilter(
+        grpc_channel_stack_type type, SourceLocation registration_source = {}) {
+      return RegisterFilter(type, &Filter::kFilter,
+                            VtableForType<Filter>::vtable(),
+                            registration_source);
+    }
 
     // Register a post processor for the builder.
     // These run after the main graph has been placed into the builder.
@@ -172,20 +218,70 @@ class ChannelInit {
                                   [static_cast<int>(PostProcessorSlot::kCount)];
   };
 
+  // A set of channel filters that can be added to a call stack.
+  // TODO(ctiller): move this out so it can be used independently of
+  // the global registration mechanisms.
+  class StackSegment final {
+   public:
+    // Registration of one channel filter in the stack.
+    struct ChannelFilter {
+      size_t offset;
+      const ChannelFilterVtable* vtable;
+    };
+
+    StackSegment() = default;
+    explicit StackSegment(std::vector<ChannelFilter> filters,
+                          uint8_t* channel_data);
+    StackSegment(const StackSegment& other) = delete;
+    StackSegment& operator=(const StackSegment& other) = delete;
+    StackSegment(StackSegment&& other) noexcept = default;
+    StackSegment& operator=(StackSegment&& other) = default;
+
+    // Add this segment to a call filter stack builder
+    void AddToCallFilterStack(CallFilters::StackBuilder& builder);
+
+   private:
+    // Combined channel data for the stack
+    class ChannelData : public RefCounted<ChannelData> {
+     public:
+      explicit ChannelData(std::vector<ChannelFilter> filters,
+                           uint8_t* channel_data);
+      ~ChannelData() override;
+
+      void AddToCallFilterStack(CallFilters::StackBuilder& builder);
+
+     private:
+      std::vector<ChannelFilter> filters_;
+      uint8_t* channel_data_;
+    };
+
+    RefCountedPtr<ChannelData> data_;
+  };
+
   /// Construct a channel stack of some sort: see channel_stack.h for details
   /// \a builder is the channel stack builder to build into.
   GRPC_MUST_USE_RESULT
   bool CreateStack(ChannelStackBuilder* builder) const;
 
+  // Create a segment of a channel stack.
+  // Terminators and post processors are not included in this construction:
+  // terminators are a legacy filter-stack concept, and post processors
+  // need to migrate to other mechanisms.
+  // TODO(ctiller): figure out other mechanisms.
+  absl::StatusOr<StackSegment> CreateStackSegment(
+      grpc_channel_stack_type type, const ChannelArgs& args) const;
+
  private:
   struct Filter {
-    Filter(const grpc_channel_filter* filter,
+    Filter(const grpc_channel_filter* filter, const ChannelFilterVtable* vtable,
            std::vector<InclusionPredicate> predicates,
            SourceLocation registration_source)
         : filter(filter),
+          vtable(vtable),
           predicates(std::move(predicates)),
           registration_source(registration_source) {}
     const grpc_channel_filter* filter;
+    const ChannelFilterVtable* vtable;
     std::vector<InclusionPredicate> predicates;
     SourceLocation registration_source;
     bool CheckPredicates(const ChannelArgs& args) const;
@@ -195,6 +291,18 @@ class ChannelInit {
     std::vector<Filter> terminators;
     std::vector<PostProcessor> post_processors;
   };
+
+  template <typename T, typename = void>
+  struct VtableForType {
+    static const ChannelFilterVtable* vtable() { return nullptr; }
+  };
+
+  template <typename T>
+  struct VtableForType<T, absl::void_t<typename T::Call>> {
+    static const ChannelFilterVtable kVtable;
+    static const ChannelFilterVtable* vtable() { return &kVtable; }
+  };
+
   StackConfig stack_configs_[GRPC_NUM_CHANNEL_STACK_TYPES];
 
   static StackConfig BuildStackConfig(
@@ -202,6 +310,22 @@ class ChannelInit {
       PostProcessor* post_processors, grpc_channel_stack_type type);
 };
 
+template <typename T>
+const ChannelInit::ChannelFilterVtable
+    ChannelInit::VtableForType<T, absl::void_t<typename T::Call>>::kVtable = {
+        sizeof(T), alignof(T),
+        [](void* data, const ChannelArgs& args) -> absl::Status {
+          // TODO(ctiller): fill in ChannelFilter::Args (2nd arg)
+          absl::StatusOr<T> r = T::Create(args, {});
+          if (!r.ok()) return r.status();
+          new (data) T(std::move(*r));
+          return absl::OkStatus();
+        },
+        [](void* data) { static_cast<T*>(data)->~T(); },
+        [](void* data, CallFilters::StackBuilder& builder) {
+          builder.Add(static_cast<T*>(data));
+        }};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_INIT_H