grpc 1.64.0 → 1.65.0.pre1

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

@@ -27,6 +27,7 @@
 #include <type_traits>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
@@ -35,7 +36,6 @@
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channel_stack_trace.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -104,9 +104,9 @@ ChannelInit::FilterRegistration::ExcludeFromMinimalStack() {
 
 ChannelInit::FilterRegistration& ChannelInit::Builder::RegisterFilter(
     grpc_channel_stack_type type, const grpc_channel_filter* filter,
-    const ChannelFilterVtable* vtable, SourceLocation registration_source) {
+    FilterAdder filter_adder, SourceLocation registration_source) {
   filters_[type].emplace_back(std::make_unique<FilterRegistration>(
-      filter, vtable, registration_source));
+      filter, filter_adder, registration_source));
   return *filters_[type].back();
 }
 
@@ -223,9 +223,10 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
   while (!dependencies.empty()) {
     auto filter = take_ready_dependency();
     auto* registration = filter_to_registration[filter];
-    filters.emplace_back(
-        filter, registration->vtable_, std::move(registration->predicates_),
-        registration->skip_v3_, registration->registration_source_);
+    filters.emplace_back(filter, registration->filter_adder_,
+                         std::move(registration->predicates_),
+                         registration->skip_v3_,
+                         registration->registration_source_);
     for (auto& p : dependencies) {
       p.second.erase(filter);
     }
@@ -239,7 +240,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
     post_processor_functions.emplace_back(std::move(post_processors[i]));
   }
   // Log out the graph we built if that's been requested.
-  if (grpc_trace_channel_stack.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
     // It can happen that multiple threads attempt to construct a core config at
     // once.
     // This is benign - the first one wins and others are discarded.
@@ -249,8 +250,8 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
     MutexLock lock(m);
     // List the channel stack type (since we'll be repeatedly printing graphs in
     // this loop).
-    gpr_log(GPR_INFO,
-            "ORDERED CHANNEL STACK %s:", grpc_channel_stack_type_string(type));
+    LOG(INFO) << "ORDERED CHANNEL STACK "
+              << grpc_channel_stack_type_string(type) << ":";
     // First build up a map of filter -> file:line: strings, because it helps
     // the readability of this log to get later fields aligned vertically.
     std::map<const grpc_channel_filter*, std::string> loc_strs;
@@ -312,7 +313,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
       const auto filter_str =
           absl::StrCat("  ", loc_strs[filter.filter],
                        NameFromChannelFilter(filter.filter), after_str);
-      gpr_log(GPR_INFO, "%s", filter_str.c_str());
+      LOG(INFO) << filter_str;
     }
     // Finally list out the terminal filters and where they were registered
     // from.
@@ -324,7 +325,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
                           strlen(NameFromChannelFilter(terminal.filter)),
                       ' '),
           "[terminal]");
-      gpr_log(GPR_INFO, "%s", filter_str.c_str());
+      LOG(INFO) << filter_str;
     }
   }
   // Check if there are no terminal filters: this would be an error.
@@ -397,7 +398,7 @@ bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
             "\n");
       }
     }
-    gpr_log(GPR_ERROR, "%s", error.c_str());
+    LOG(ERROR) << error;
     return false;
   }
   for (const auto& post_processor : stack_config.post_processors) {
@@ -406,78 +407,21 @@ bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
   return true;
 }
 
-absl::StatusOr<ChannelInit::StackSegment> ChannelInit::CreateStackSegment(
-    grpc_channel_stack_type type, const ChannelArgs& args) const {
+void ChannelInit::AddToInterceptionChainBuilder(
+    grpc_channel_stack_type type, InterceptionChainBuilder& builder) 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.skip_v3) continue;
-    if (!filter.CheckPredicates(args)) continue;
-    if (filter.vtable == nullptr) {
-      return absl::InvalidArgumentError(
+    if (!filter.CheckPredicates(builder.channel_args())) continue;
+    if (filter.filter_adder == nullptr) {
+      builder.Fail(absl::InvalidArgumentError(
           absl::StrCat("Filter ", NameFromChannelFilter(filter.filter),
-                       " has no v3-callstack vtable"));
+                       " has no v3-callstack vtable")));
+      return;
     }
-    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);
+    filter.filter_adder(builder);
   }
-  gpr_free_aligned(channel_data_);
 }
 
 }  // namespace grpc_core

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

@@ -38,6 +38,7 @@
 #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"
+#include "src/core/lib/transport/interception_chain.h"
 
 /// This module provides a way for plugins (and the grpc core library itself)
 /// to register mutators for channel stacks.
@@ -68,6 +69,8 @@ class ChannelInit {
   using InclusionPredicate = absl::AnyInvocable<bool(const ChannelArgs&) const>;
   // Post processor for the channel stack - applied in PostProcessorSlot order
   using PostProcessor = absl::AnyInvocable<void(ChannelStackBuilder&) const>;
+  // Function that can be called to add a filter to a stack builder
+  using FilterAdder = void (*)(InterceptionChainBuilder&);
   // Post processing slots - up to one PostProcessor per slot can be registered
   // They run after filters registered are added to the channel stack builder,
   // but before Build is called - allowing ad-hoc mutation to the channel stack.
@@ -77,25 +80,15 @@ 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,
+                                FilterAdder filter_adder,
                                 SourceLocation registration_source)
         : filter_(filter),
-          vtable_(vtable),
+          filter_adder_(filter_adder),
           registration_source_(registration_source) {}
     FilterRegistration(const FilterRegistration&) = delete;
     FilterRegistration& operator=(const FilterRegistration&) = delete;
@@ -170,7 +163,7 @@ class ChannelInit {
    private:
     friend class ChannelInit;
     const grpc_channel_filter* const filter_;
-    const ChannelFilterVtable* const vtable_;
+    const FilterAdder filter_adder_;
     std::vector<const grpc_channel_filter*> after_;
     std::vector<const grpc_channel_filter*> before_;
     std::vector<InclusionPredicate> predicates_;
@@ -188,16 +181,17 @@ class ChannelInit {
     // properties of the filter being registered.
     // 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 = {});
+    FilterRegistration& RegisterFilter(grpc_channel_stack_type type,
+                                       const grpc_channel_filter* filter,
+                                       FilterAdder filter_adder = 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);
+      return RegisterFilter(
+          type, &Filter::kFilter,
+          [](InterceptionChainBuilder& builder) { builder.Add<Filter>(); },
+          registration_source);
     }
 
     // Filter does not participate in v3
@@ -232,58 +226,13 @@ 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;
+  void AddToInterceptionChainBuilder(grpc_channel_stack_type type,
+                                     InterceptionChainBuilder& builder) const;
 
  private:
   // The type of object returned by a filter's Create method.
@@ -292,16 +241,16 @@ class ChannelInit {
       typename decltype(T::Create(ChannelArgs(), {}))::value_type;
 
   struct Filter {
-    Filter(const grpc_channel_filter* filter, const ChannelFilterVtable* vtable,
+    Filter(const grpc_channel_filter* filter, FilterAdder filter_adder,
            std::vector<InclusionPredicate> predicates, bool skip_v3,
            SourceLocation registration_source)
         : filter(filter),
-          vtable(vtable),
+          filter_adder(filter_adder),
           predicates(std::move(predicates)),
           registration_source(registration_source),
           skip_v3(skip_v3) {}
     const grpc_channel_filter* filter;
-    const ChannelFilterVtable* vtable;
+    const FilterAdder filter_adder;
     std::vector<InclusionPredicate> predicates;
     SourceLocation registration_source;
     bool skip_v3 = false;
@@ -313,17 +262,6 @@ class ChannelInit {
     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(
@@ -331,22 +269,6 @@ 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(CreatedType<T>), alignof(CreatedType<T>),
-        [](void* data, const ChannelArgs& args) -> absl::Status {
-          // TODO(ctiller): fill in ChannelFilter::Args (2nd arg)
-          absl::StatusOr<CreatedType<T>> r = T::Create(args, {});
-          if (!r.ok()) return r.status();
-          new (data) CreatedType<T>(std::move(*r));
-          return absl::OkStatus();
-        },
-        [](void* data) { Destruct(static_cast<CreatedType<T>*>(data)); },
-        [](void* data, CallFilters::StackBuilder& builder) {
-          builder.Add(static_cast<CreatedType<T>*>(data)->get());
-        }};
-
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_INIT_H