grpc 1.46.3 → 1.47.0

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

@@ -21,9 +21,18 @@
 
 #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"
@@ -31,11 +40,21 @@
 #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 +78,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 +92,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 +111,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 +163,69 @@ 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) {
+      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 +245,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 +297,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 +320,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 +343,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 +406,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 +424,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 +440,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 +480,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 +493,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 +517,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_internal.cc

@@ -52,6 +52,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 +207,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

@@ -73,7 +73,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/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/event_engine/channel_args_endpoint_config.cc

@@ -15,12 +15,14 @@
 
 #include "src/core/lib/event_engine/channel_args_endpoint_config.h"
 
+#include <string>
+
+#include "absl/types/variant.h"
+
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/impl/codegen/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/useful.h"
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/channel_args_endpoint_config.h

@@ -16,9 +16,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/event_engine/endpoint_config.h>
+#include "absl/strings/string_view.h"
 
-#include "src/core/lib/channel/channel_args.h"
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/impl/codegen/grpc_types.h>
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/default_event_engine_factory.cc

@@ -13,14 +13,20 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
+#include "absl/memory/memory.h"
+
+#include <grpc/event_engine/event_engine.h>
+
 #include "src/core/lib/event_engine/event_engine_factory.h"
+#include "src/core/lib/event_engine/iomgr_engine.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
 std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
-  // TODO(hork): call LibuvEventEngineFactory
-  return nullptr;
+  return absl::make_unique<IomgrEventEngine>();
 }
 
 }  // namespace experimental

data/src/core/lib/event_engine/event_engine.cc

@@ -13,11 +13,14 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
+#include <functional>
+#include <memory>
+
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/event_engine/port.h>
-#include <grpc/support/log.h>
 
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/event_engine_factory.h"
+#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
@@ -48,5 +51,12 @@ EventEngine* GetDefaultEventEngine() {
   return default_event_engine;
 }
 
+void InitializeEventEngine() {
+  GetDefaultEventEngine()->Run([]() {
+    GRPC_EVENT_ENGINE_TRACE("EventEngine:%p initialized",
+                            GetDefaultEventEngine());
+  });
+}
+
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/event_engine/event_engine_factory.h

@@ -16,6 +16,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
 #include <grpc/event_engine/event_engine.h>
 
 namespace grpc_event_engine {
@@ -30,6 +32,9 @@ EventEngine* GetDefaultEventEngine();
 /// Create an EventEngine using the default factory provided at link time.
 std::unique_ptr<EventEngine> DefaultEventEngineFactory();
 
+// TODO(hork): remove this when any other EE usage is landed
+void InitializeEventEngine();
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

data/src/core/lib/event_engine/handle_containers.h

@@ -0,0 +1,67 @@
+// Copyright 2022 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <cstdint>
+#include <utility>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/hash/hash.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Used for heterogeneous lookup of TaskHandles in abseil containers.
+template <typename TaskHandle>
+struct TaskHandleComparator {
+  struct Hash {
+    using HashType = std::pair<const intptr_t, const intptr_t>;
+    using is_transparent = void;
+    size_t operator()(const TaskHandle& handle) const {
+      return absl::Hash<HashType>()({handle.keys[0], handle.keys[1]});
+    }
+  };
+  struct Eq {
+    using is_transparent = void;
+    bool operator()(const TaskHandle& lhs, const TaskHandle& rhs) const {
+      return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
+    }
+  };
+};
+
+using TaskHandleSet = absl::flat_hash_set<
+    grpc_event_engine::experimental::EventEngine::TaskHandle,
+    TaskHandleComparator<
+        grpc_event_engine::experimental::EventEngine::TaskHandle>::Hash,
+    TaskHandleComparator<
+        grpc_event_engine::experimental::EventEngine::TaskHandle>::Eq>;
+
+using LookupTaskHandleSet = absl::flat_hash_set<
+    grpc_event_engine::experimental::EventEngine::DNSResolver::LookupTaskHandle,
+    TaskHandleComparator<grpc_event_engine::experimental::EventEngine::
+                             DNSResolver::LookupTaskHandle>::Hash,
+    TaskHandleComparator<grpc_event_engine::experimental::EventEngine::
+                             DNSResolver::LookupTaskHandle>::Eq>;
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H