grpc 1.46.3-x86_64-linux → 1.48.0-x86_64-linux

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

@@ -21,21 +21,41 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/utility/utility.h"
+#include <stdint.h>
+#include <stdlib.h>
 
-#include <grpc/status.h>
+#include <atomic>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/meta/type_traits.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
@@ -59,6 +79,9 @@ class ChannelFilter {
     grpc_channel_element* channel_element_;
   };
 
+  // Perform post-initialization step (if any).
+  virtual void PostInit() {}
+
   // Construct a promise for one call.
   virtual ArenaPromise<ServerMetadataHandle> MakeCallPromise(
       CallArgs call_args, NextPromiseFactory next_promise_factory) = 0;
@@ -70,12 +93,18 @@ class ChannelFilter {
   // structures going forward.
   virtual bool StartTransportOp(grpc_transport_op*) { return false; }
 
+  // Perform a legacy get info call
+  // Return true if the op was handled, false if it should be passed to the
+  // next filter.
+  // TODO(ctiller): design a new API for this
+  virtual bool GetChannelInfo(const grpc_channel_info*) { return false; }
+
   virtual ~ChannelFilter() = default;
 };
 
 // Designator for whether a filter is client side or server side.
-// Please don't use this outside calls to MakePromiseBasedFilter - it's intended
-// to be deleted once the promise conversion is complete.
+// Please don't use this outside calls to MakePromiseBasedFilter - it's
+// intended to be deleted once the promise conversion is complete.
 enum class FilterEndpoint {
   kClient,
   kServer,
@@ -83,9 +112,20 @@ enum class FilterEndpoint {
 
 // Flags for MakePromiseBasedFilter.
 static constexpr uint8_t kFilterExaminesServerInitialMetadata = 1;
+static constexpr uint8_t kFilterIsLast = 2;
 
 namespace promise_filter_detail {
 
+// Proxy channel filter for initialization failure, since we must leave a
+// valid filter in place.
+class InvalidChannelFilter : public ChannelFilter {
+ public:
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs, NextPromiseFactory) override {
+    abort();
+  }
+};
+
 // Call data shared between all implementations of promise-based filters.
 class BaseCallData : public Activity, private Wakeable {
  public:
@@ -124,6 +164,70 @@ class BaseCallData : public Activity, private Wakeable {
     }
   };
 
+  class Flusher {
+   public:
+    explicit Flusher(BaseCallData* call);
+    // Calls closures, schedules batches, relinquishes call combiner.
+    ~Flusher();
+
+    void Resume(grpc_transport_stream_op_batch* batch) {
+      GPR_ASSERT(!call_->is_last());
+      release_.push_back(batch);
+    }
+
+    void Cancel(grpc_transport_stream_op_batch* batch,
+                grpc_error_handle error) {
+      grpc_transport_stream_op_batch_queue_finish_with_failure(batch, error,
+                                                               &call_closures_);
+    }
+
+    void Complete(grpc_transport_stream_op_batch* batch) {
+      call_closures_.Add(batch->on_complete, GRPC_ERROR_NONE,
+                         "Flusher::Complete");
+    }
+
+    void AddClosure(grpc_closure* closure, grpc_error_handle error,
+                    const char* reason) {
+      call_closures_.Add(closure, error, reason);
+    }
+
+   private:
+    absl::InlinedVector<grpc_transport_stream_op_batch*, 1> release_;
+    CallCombinerClosureList call_closures_;
+    BaseCallData* const call_;
+  };
+
+  // Smart pointer like wrapper around a batch.
+  // Creation makes a ref count of one capture.
+  // Copying increments.
+  // Must be moved from or resumed or cancelled before destruction.
+  class CapturedBatch final {
+   public:
+    CapturedBatch();
+    explicit CapturedBatch(grpc_transport_stream_op_batch* batch);
+    ~CapturedBatch();
+    CapturedBatch(const CapturedBatch&);
+    CapturedBatch& operator=(const CapturedBatch&);
+    CapturedBatch(CapturedBatch&&) noexcept;
+    CapturedBatch& operator=(CapturedBatch&&) noexcept;
+
+    grpc_transport_stream_op_batch* operator->() { return batch_; }
+    bool is_captured() const { return batch_ != nullptr; }
+
+    // Resume processing this batch (releases one ref, passes it down the
+    // stack)
+    void ResumeWith(Flusher* releaser);
+    // Cancel this batch immediately (releases all refs)
+    void CancelWith(grpc_error_handle error, Flusher* releaser);
+    // Complete this batch (pass it up) assuming refs drop to zero
+    void CompleteWith(Flusher* releaser);
+
+    void Swap(CapturedBatch* other) { std::swap(batch_, other->batch_); }
+
+   private:
+    grpc_transport_stream_op_batch* batch_;
+  };
+
   static MetadataHandle<grpc_metadata_batch> WrapMetadata(
       grpc_metadata_batch* p) {
     return MetadataHandle<grpc_metadata_batch>(p);
@@ -143,6 +247,11 @@ class BaseCallData : public Activity, private Wakeable {
     return server_initial_metadata_latch_;
   }
 
+  bool is_last() const {
+    return grpc_call_stack_element(call_stack_, call_stack_->count - 1) ==
+           elem_;
+  }
+
  private:
   // Wakeable implementation.
   void Wakeup() final;
@@ -190,7 +299,8 @@ class ClientCallData : public BaseCallData {
     // Start state: no op seen
     kInitial,
     // We saw the op, and since it was bundled with send initial metadata, we
-    // queued it until the send initial metadata can be sent to the next filter.
+    // queued it until the send initial metadata can be sent to the next
+    // filter.
     kQueued,
     // We've forwarded the op to the next filter.
     kForwarded,
@@ -212,11 +322,11 @@ class ClientCallData : public BaseCallData {
   void Cancel(grpc_error_handle error);
   // Begin running the promise - which will ultimately take some initial
   // metadata and return some trailing metadata.
-  void StartPromise();
-  // Interject our callback into the op batch for recv trailing metadata ready.
-  // Stash a pointer to the trailing metadata that will be filled in, so we can
-  // manipulate it later.
-  void HookRecvTrailingMetadata(grpc_transport_stream_op_batch* batch);
+  void StartPromise(Flusher* flusher);
+  // Interject our callback into the op batch for recv trailing metadata
+  // ready. Stash a pointer to the trailing metadata that will be filled in,
+  // so we can manipulate it later.
+  void HookRecvTrailingMetadata(CapturedBatch batch);
   // Construct a promise that will "call" the next filter.
   // Effectively:
   //   - put the modified initial metadata into the batch to be sent down.
@@ -235,13 +345,13 @@ class ClientCallData : public BaseCallData {
   void SetStatusFromError(grpc_metadata_batch* metadata,
                           grpc_error_handle error);
   // Wakeup and poll the promise if appropriate.
-  void WakeInsideCombiner();
+  void WakeInsideCombiner(Flusher* flusher);
   void OnWakeup() override;
 
   // Contained promise
   ArenaPromise<ServerMetadataHandle> promise_;
   // Queued batch containing at least a send_initial_metadata op.
-  grpc_transport_stream_op_batch* send_initial_metadata_batch_ = nullptr;
+  CapturedBatch send_initial_metadata_batch_;
   // Pointer to where trailing metadata will be stored.
   grpc_metadata_batch* recv_trailing_metadata_ = nullptr;
   // State tracking recv initial metadata for filters that care about it.
@@ -298,8 +408,11 @@ class ServerCallData : public BaseCallData {
     kCancelled
   };
 
+  class PollContext;
+  struct SendInitialMetadata;
+
   // Handle cancellation.
-  void Cancel(grpc_error_handle error);
+  void Cancel(grpc_error_handle error, Flusher* flusher);
   // Construct a promise that will "call" the next filter.
   // Effectively:
   //   - put the modified initial metadata into the batch being sent up.
@@ -313,13 +426,15 @@ class ServerCallData : public BaseCallData {
                                                grpc_error_handle error);
   void RecvInitialMetadataReady(grpc_error_handle error);
   // Wakeup and poll the promise if appropriate.
-  void WakeInsideCombiner(absl::FunctionRef<void(grpc_error_handle)> cancel);
+  void WakeInsideCombiner(Flusher* flusher);
   void OnWakeup() override;
 
   // Contained promise
   ArenaPromise<ServerMetadataHandle> promise_;
   // Pointer to where initial metadata will be stored.
   grpc_metadata_batch* recv_initial_metadata_ = nullptr;
+  // State for sending initial metadata.
+  SendInitialMetadata* send_initial_metadata_ = nullptr;
   // Closure to call when we're done with the trailing metadata.
   grpc_closure* original_recv_initial_metadata_ready_ = nullptr;
   // Our closure pointing to RecvInitialMetadataReadyCallback.
@@ -327,13 +442,13 @@ class ServerCallData : public BaseCallData {
   // Error received during cancellation.
   grpc_error_handle cancelled_error_ = GRPC_ERROR_NONE;
   // Trailing metadata batch
-  grpc_transport_stream_op_batch* send_trailing_metadata_batch_ = nullptr;
+  CapturedBatch send_trailing_metadata_batch_;
   // State of the send_initial_metadata op.
   RecvInitialState recv_initial_state_ = RecvInitialState::kInitial;
   // State of the recv_trailing_metadata op.
   SendTrailingState send_trailing_state_ = SendTrailingState::kInitial;
-  // Whether we're currently polling the promise.
-  bool is_polling_ = false;
+  // Current poll context (or nullptr if not polling).
+  PollContext* poll_ctx_ = nullptr;
   // Whether to forward the recv_initial_metadata op at the end of promise
   // wakeup.
   bool forward_recv_initial_metadata_callback_ = false;
@@ -367,8 +482,6 @@ class CallData<ChannelFilter, FilterEndpoint::kServer> : public ServerCallData {
 //   static absl::StatusOr<SomeChannelFilter> Create(
 //       ChannelArgs channel_args, ChannelFilter::Args filter_args);
 // };
-// TODO(ctiller): allow implementing get_channel_info, start_transport_op in
-// some way on ChannelFilter.
 template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
 absl::enable_if_t<std::is_base_of<ChannelFilter, F>::value, grpc_channel_filter>
 MakePromiseBasedFilter(const char* name) {
@@ -382,13 +495,14 @@ MakePromiseBasedFilter(const char* name) {
       // make_call_promise
       [](grpc_channel_element* elem, CallArgs call_args,
          NextPromiseFactory next_promise_factory) {
-        return static_cast<F*>(elem->channel_data)
+        return static_cast<ChannelFilter*>(elem->channel_data)
             ->MakeCallPromise(std::move(call_args),
                               std::move(next_promise_factory));
       },
       // start_transport_op
       [](grpc_channel_element* elem, grpc_transport_op* op) {
-        if (!static_cast<F*>(elem->channel_data)->StartTransportOp(op)) {
+        if (!static_cast<ChannelFilter*>(elem->channel_data)
+                 ->StartTransportOp(op)) {
           grpc_channel_next_op(elem, op);
         }
       },
@@ -405,28 +519,49 @@ MakePromiseBasedFilter(const char* name) {
       },
       // destroy_call_elem
       [](grpc_call_element* elem, const grpc_call_final_info* final_info,
-         grpc_closure*) {
+         grpc_closure* then_schedule_closure) {
         auto* cd = static_cast<CallData*>(elem->call_data);
         cd->Finalize(final_info);
         cd->~CallData();
+        if ((kFlags & kFilterIsLast) != 0) {
+          ExecCtx::Run(DEBUG_LOCATION, then_schedule_closure, GRPC_ERROR_NONE);
+        } else {
+          GPR_ASSERT(then_schedule_closure == nullptr);
+        }
       },
       // sizeof_channel_data
       sizeof(F),
       // init_channel_elem
       [](grpc_channel_element* elem, grpc_channel_element_args* args) {
-        GPR_ASSERT(!args->is_last);
+        GPR_ASSERT(args->is_last == ((kFlags & kFilterIsLast) != 0));
         auto status = F::Create(ChannelArgs::FromC(args->channel_args),
                                 ChannelFilter::Args(args->channel_stack, elem));
-        if (!status.ok()) return absl_status_to_grpc_error(status.status());
+        if (!status.ok()) {
+          static_assert(
+              sizeof(promise_filter_detail::InvalidChannelFilter) <= sizeof(F),
+              "InvalidChannelFilter must fit in F");
+          new (elem->channel_data)
+              promise_filter_detail::InvalidChannelFilter();
+          return absl_status_to_grpc_error(status.status());
+        }
         new (elem->channel_data) F(std::move(*status));
         return GRPC_ERROR_NONE;
       },
+      // post_init_channel_elem
+      [](grpc_channel_stack*, grpc_channel_element* elem) {
+        static_cast<ChannelFilter*>(elem->channel_data)->PostInit();
+      },
       // destroy_channel_elem
       [](grpc_channel_element* elem) {
-        static_cast<F*>(elem->channel_data)->~F();
+        static_cast<ChannelFilter*>(elem->channel_data)->~ChannelFilter();
       },
       // get_channel_info
-      grpc_channel_next_get_info,
+      [](grpc_channel_element* elem, const grpc_channel_info* info) {
+        if (!static_cast<ChannelFilter*>(elem->channel_data)
+                 ->GetChannelInfo(info)) {
+          grpc_channel_next_get_info(elem, info);
+        }
+      },
       // name
       name,
   };

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

@@ -20,6 +20,8 @@
 
 #include "src/core/lib/channel/status_util.h"
 
+#include <string.h>
+
 #include "src/core/lib/gpr/useful.h"
 
 struct status_string_entry {

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

@@ -21,9 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-#include <string.h>
-
 #include <grpc/status.h>
 
 /// If \a status_str is a valid status string, sets \a status to the

data/src/core/lib/compression/compression.cc

@@ -18,12 +18,17 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
 
+#include "absl/types/optional.h"
+
 #include <grpc/compression.h>
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/slice.h>
 
 #include "src/core/lib/compression/compression_internal.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"

data/src/core/lib/compression/compression_internal.cc

@@ -23,17 +23,14 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <cstdint>
-
 #include "absl/container/inlined_vector.h"
-#include "absl/strings/str_join.h"
+#include "absl/strings/ascii.h"
 #include "absl/strings/str_split.h"
 
-#include <grpc/compression.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/api_trace.h"
 
 namespace grpc_core {
@@ -52,6 +49,48 @@ const char* CompressionAlgorithmAsString(grpc_compression_algorithm algorithm) {
   }
 }
 
+namespace {
+class CommaSeparatedLists {
+ public:
+  CommaSeparatedLists() : lists_{}, text_buffer_{} {
+    char* text_buffer = text_buffer_;
+    auto add_char = [&text_buffer, this](char c) {
+      if (text_buffer - text_buffer_ == kTextBufferSize) abort();
+      *text_buffer++ = c;
+    };
+    for (size_t list = 0; list < kNumLists; ++list) {
+      char* start = text_buffer;
+      for (size_t algorithm = 0; algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT;
+           ++algorithm) {
+        if ((list & (1 << algorithm)) == 0) continue;
+        if (start != text_buffer) {
+          add_char(',');
+          add_char(' ');
+        }
+        const char* name = CompressionAlgorithmAsString(
+            static_cast<grpc_compression_algorithm>(algorithm));
+        for (const char* p = name; *p != '\0'; ++p) {
+          add_char(*p);
+        }
+      }
+      lists_[list] = absl::string_view(start, text_buffer - start);
+    }
+    if (text_buffer - text_buffer_ != kTextBufferSize) abort();
+  }
+
+  absl::string_view operator[](size_t list) const { return lists_[list]; }
+
+ private:
+  static constexpr size_t kNumLists = 1 << GRPC_COMPRESS_ALGORITHMS_COUNT;
+  // Experimentally determined (tweak things until it runs).
+  static constexpr size_t kTextBufferSize = 86;
+  absl::string_view lists_[kNumLists];
+  char text_buffer_[kTextBufferSize];
+};
+
+const CommaSeparatedLists kCommaSeparatedLists;
+}  // namespace
+
 absl::optional<grpc_compression_algorithm> ParseCompressionAlgorithm(
     absl::string_view algorithm) {
   if (algorithm == "identity") {
@@ -165,19 +204,12 @@ void CompressionAlgorithmSet::Set(grpc_compression_algorithm algorithm) {
   }
 }
 
-std::string CompressionAlgorithmSet::ToString() const {
-  absl::InlinedVector<const char*, GRPC_COMPRESS_ALGORITHMS_COUNT> segments;
-  for (size_t i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
-    if (set_.is_set(i)) {
-      segments.push_back(CompressionAlgorithmAsString(
-          static_cast<grpc_compression_algorithm>(i)));
-    }
-  }
-  return absl::StrJoin(segments, ", ");
+absl::string_view CompressionAlgorithmSet::ToString() const {
+  return kCommaSeparatedLists[ToLegacyBitmask()];
 }
 
 Slice CompressionAlgorithmSet::ToSlice() const {
-  return Slice::FromCopiedString(ToString());
+  return Slice::FromStaticString(ToString());
 }
 
 CompressionAlgorithmSet CompressionAlgorithmSet::FromString(

data/src/core/lib/compression/compression_internal.h

@@ -21,14 +21,15 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <initializer_list>
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/compression.h>
+#include <grpc/impl/codegen/compression_types.h>
 #include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/slice.h>
 
 #include "src/core/lib/gprpp/bitset.h"
 #include "src/core/lib/slice/slice.h"
@@ -73,7 +74,7 @@ class CompressionAlgorithmSet {
   void Set(grpc_compression_algorithm algorithm);
 
   // Return a comma separated string of the algorithms in this set.
-  std::string ToString() const;
+  absl::string_view ToString() const;
   Slice ToSlice() const;
 
   // Return a bitmask of the algorithms in this set.

data/src/core/lib/compression/message_compress.cc

@@ -22,12 +22,14 @@
 
 #include <string.h>
 
+#include <zconf.h>
 #include <zlib.h>
 
+#include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
 
 #define OUTPUT_BLOCK_SIZE 1024
 

data/src/core/lib/compression/message_compress.h

@@ -21,9 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice_buffer.h>
-
-#include "src/core/lib/compression/compression_internal.h"
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/slice.h>
 
 /* compress 'input' to 'output' using 'algorithm'.
    On success, appends compressed slices to output and returns 1.

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

@@ -16,7 +16,10 @@
 
 #include "src/core/lib/config/core_configuration.h"
 
+#include <algorithm>
 #include <atomic>
+#include <utility>
+#include <vector>
 
 #include <grpc/support/log.h>
 

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

@@ -18,13 +18,14 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
+#include <functional>
 
 #include "src/core/lib/channel/channel_args_preconditioning.h"
-#include "src/core/lib/channel/handshaker_registry.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 #include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/transport/handshaker_registry.h"
 
 namespace grpc_core {
 

data/src/core/lib/debug/stats.cc

@@ -23,28 +23,28 @@
 #include <inttypes.h>
 #include <string.h>
 
+#include <algorithm>
 #include <vector>
 
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
+#include <grpc/support/cpu.h>
+#include <grpc/support/sync.h>
 
 grpc_stats_data* grpc_stats_per_cpu_storage = nullptr;
 static size_t g_num_cores;
+static gpr_once g_once = GPR_ONCE_INIT;
 
 void grpc_stats_init(void) {
-  g_num_cores = std::max(1u, gpr_cpu_num_cores());
-  grpc_stats_per_cpu_storage = static_cast<grpc_stats_data*>(
-      gpr_zalloc(sizeof(grpc_stats_data) * g_num_cores));
+  gpr_once_init(&g_once, []() {
+    g_num_cores = gpr_cpu_num_cores();
+    grpc_stats_per_cpu_storage = static_cast<grpc_stats_data*>(
+        gpr_zalloc(sizeof(grpc_stats_data) * g_num_cores));
+  });
 }
 
-void grpc_stats_shutdown(void) { gpr_free(grpc_stats_per_cpu_storage); }
-
 void grpc_stats_collect(grpc_stats_data* output) {
   memset(output, 0, sizeof(*output));
   for (size_t core = 0; core < g_num_cores; core++) {

data/src/core/lib/debug/stats.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <string>
 
 #include <grpc/support/atm.h>
@@ -54,7 +56,6 @@ extern grpc_stats_data* grpc_stats_per_cpu_storage;
 #endif /* defined(GRPC_COLLECT_STATS) || !defined(NDEBUG) */
 
 void grpc_stats_init(void);
-void grpc_stats_shutdown(void);
 void grpc_stats_collect(grpc_stats_data* output);
 // c = b-a
 void grpc_stats_diff(const grpc_stats_data* b, const grpc_stats_data* a,

data/src/core/lib/debug/stats_data.cc

@@ -22,9 +22,10 @@
 
 #include "src/core/lib/debug/stats_data.h"
 
+#include <inttypes.h>
+
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 
 const char* grpc_stats_counter_name[GRPC_STATS_COUNTER_COUNT] = {
     "client_calls_created",

data/src/core/lib/debug/stats_data.h

@@ -23,10 +23,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <inttypes.h>
-
-#include "src/core/lib/iomgr/exec_ctx.h"
-
 typedef enum {
   GRPC_STATS_COUNTER_CLIENT_CALLS_CREATED,
   GRPC_STATS_COUNTER_SERVER_CALLS_CREATED,