grpc 1.53.2 → 1.54.0

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

@@ -0,0 +1,151 @@
+// Copyright 2023 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.
+
+//
+// Automatically generated by tools/codegen/core/gen_config_vars.py
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/config/config_vars.h"
+
+#include "absl/flags/flag.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
+
+#include "src/core/lib/config/load_config.h"
+
+#ifndef GPR_DEFAULT_LOG_VERBOSITY_STRING
+#define GPR_DEFAULT_LOG_VERBOSITY_STRING "ERROR"
+#endif  // !GPR_DEFAULT_LOG_VERBOSITY_STRING
+
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+#define GRPC_ENABLE_FORK_SUPPORT_DEFAULT true
+#else
+#define GRPC_ENABLE_FORK_SUPPORT_DEFAULT false
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+ABSL_FLAG(absl::optional<std::string>, grpc_experiments, absl::nullopt,
+          "A comma separated list of currently active experiments. Experiments "
+          "may be prefixed with a '-' to disable them.");
+ABSL_FLAG(absl::optional<int32_t>, grpc_client_channel_backup_poll_interval_ms,
+          absl::nullopt,
+          "Declares the interval in ms between two backup polls on client "
+          "channels. These polls are run in the timer thread so that gRPC can "
+          "process connection failures while there is no active polling "
+          "thread. They help reconnect disconnected client channels (mostly "
+          "due to idleness), so that the next RPC on this channel won't fail. "
+          "Set to 0 to turn off the backup polls.");
+ABSL_FLAG(absl::optional<std::string>, grpc_dns_resolver, absl::nullopt,
+          "Declares which DNS resolver to use. The default is ares if gRPC is "
+          "built with c-ares support. Otherwise, the value of this environment "
+          "variable is ignored.");
+ABSL_FLAG(absl::optional<std::string>, grpc_trace, absl::nullopt,
+          "A comma separated list of tracers that provide additional insight "
+          "into how gRPC C core is processing requests via debug logs.");
+ABSL_FLAG(absl::optional<std::string>, grpc_verbosity, absl::nullopt,
+          "Default gRPC logging verbosity");
+ABSL_FLAG(absl::optional<std::string>, grpc_stacktrace_minloglevel,
+          absl::nullopt,
+          "Messages logged at the same or higher level than this will print "
+          "stacktrace");
+ABSL_FLAG(absl::optional<bool>, grpc_enable_fork_support, absl::nullopt,
+          "Enable fork support");
+ABSL_FLAG(absl::optional<std::string>, grpc_poll_strategy, absl::nullopt,
+          "Declares which polling engines to try when starting gRPC. This is a "
+          "comma-separated list of engines, which are tried in priority order "
+          "first -> last.");
+ABSL_FLAG(absl::optional<bool>, grpc_abort_on_leaks, absl::nullopt,
+          "A debugging aid to cause a call to abort() when gRPC objects are "
+          "leaked past grpc_shutdown()");
+ABSL_FLAG(absl::optional<std::string>, grpc_system_ssl_roots_dir, absl::nullopt,
+          "Custom directory to SSL Roots");
+ABSL_FLAG(absl::optional<std::string>, grpc_default_ssl_roots_file_path,
+          absl::nullopt, "Path to the default SSL roots file.");
+ABSL_FLAG(absl::optional<bool>, grpc_not_use_system_ssl_roots, absl::nullopt,
+          "Disable loading system root certificates.");
+ABSL_FLAG(absl::optional<std::string>, grpc_ssl_cipher_suites, absl::nullopt,
+          "A colon separated list of cipher suites to use with OpenSSL");
+
+namespace grpc_core {
+
+ConfigVars::ConfigVars(const Overrides& overrides)
+    : client_channel_backup_poll_interval_ms_(
+          LoadConfig(FLAGS_grpc_client_channel_backup_poll_interval_ms,
+                     "GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS",
+                     overrides.client_channel_backup_poll_interval_ms, 5000)),
+      enable_fork_support_(LoadConfig(
+          FLAGS_grpc_enable_fork_support, "GRPC_ENABLE_FORK_SUPPORT",
+          overrides.enable_fork_support, GRPC_ENABLE_FORK_SUPPORT_DEFAULT)),
+      abort_on_leaks_(LoadConfig(FLAGS_grpc_abort_on_leaks,
+                                 "GRPC_ABORT_ON_LEAKS",
+                                 overrides.abort_on_leaks, false)),
+      not_use_system_ssl_roots_(LoadConfig(
+          FLAGS_grpc_not_use_system_ssl_roots, "GRPC_NOT_USE_SYSTEM_SSL_ROOTS",
+          overrides.not_use_system_ssl_roots, false)),
+      experiments_(LoadConfig(FLAGS_grpc_experiments, "GRPC_EXPERIMENTS",
+                              overrides.experiments, "")),
+      dns_resolver_(LoadConfig(FLAGS_grpc_dns_resolver, "GRPC_DNS_RESOLVER",
+                               overrides.dns_resolver, "")),
+      trace_(LoadConfig(FLAGS_grpc_trace, "GRPC_TRACE", overrides.trace, "")),
+      verbosity_(LoadConfig(FLAGS_grpc_verbosity, "GRPC_VERBOSITY",
+                            overrides.verbosity,
+                            GPR_DEFAULT_LOG_VERBOSITY_STRING)),
+      stacktrace_minloglevel_(LoadConfig(FLAGS_grpc_stacktrace_minloglevel,
+                                         "GRPC_STACKTRACE_MINLOGLEVEL",
+                                         overrides.stacktrace_minloglevel, "")),
+      poll_strategy_(LoadConfig(FLAGS_grpc_poll_strategy, "GRPC_POLL_STRATEGY",
+                                overrides.poll_strategy, "all")),
+      ssl_cipher_suites_(LoadConfig(
+          FLAGS_grpc_ssl_cipher_suites, "GRPC_SSL_CIPHER_SUITES",
+          overrides.ssl_cipher_suites,
+          "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_"
+          "SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:"
+          "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384")),
+      override_system_ssl_roots_dir_(overrides.system_ssl_roots_dir),
+      override_default_ssl_roots_file_path_(
+          overrides.default_ssl_roots_file_path) {}
+
+std::string ConfigVars::SystemSslRootsDir() const {
+  return LoadConfig(FLAGS_grpc_system_ssl_roots_dir,
+                    "GRPC_SYSTEM_SSL_ROOTS_DIR", override_system_ssl_roots_dir_,
+                    "");
+}
+
+std::string ConfigVars::DefaultSslRootsFilePath() const {
+  return LoadConfig(FLAGS_grpc_default_ssl_roots_file_path,
+                    "GRPC_DEFAULT_SSL_ROOTS_FILE_PATH",
+                    override_default_ssl_roots_file_path_, "");
+}
+
+std::string ConfigVars::ToString() const {
+  return absl::StrCat(
+      "experiments: ", "\"", absl::CEscape(Experiments()), "\"",
+      ", client_channel_backup_poll_interval_ms: ",
+      ClientChannelBackupPollIntervalMs(), ", dns_resolver: ", "\"",
+      absl::CEscape(DnsResolver()), "\"", ", trace: ", "\"",
+      absl::CEscape(Trace()), "\"", ", verbosity: ", "\"",
+      absl::CEscape(Verbosity()), "\"", ", stacktrace_minloglevel: ", "\"",
+      absl::CEscape(StacktraceMinloglevel()), "\"",
+      ", enable_fork_support: ", EnableForkSupport() ? "true" : "false",
+      ", poll_strategy: ", "\"", absl::CEscape(PollStrategy()), "\"",
+      ", abort_on_leaks: ", AbortOnLeaks() ? "true" : "false",
+      ", system_ssl_roots_dir: ", "\"", absl::CEscape(SystemSslRootsDir()),
+      "\"", ", default_ssl_roots_file_path: ", "\"",
+      absl::CEscape(DefaultSslRootsFilePath()), "\"",
+      ", not_use_system_ssl_roots: ", NotUseSystemSslRoots() ? "true" : "false",
+      ", ssl_cipher_suites: ", "\"", absl::CEscape(SslCipherSuites()), "\"");
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,127 @@
+// Copyright 2023 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.
+
+//
+// Automatically generated by tools/codegen/core/gen_config_vars.py
+//
+
+#ifndef GRPC_SRC_CORE_LIB_CONFIG_CONFIG_VARS_H
+#define GRPC_SRC_CORE_LIB_CONFIG_CONFIG_VARS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include <atomic>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+namespace grpc_core {
+
+class ConfigVars {
+ public:
+  struct Overrides {
+    absl::optional<int32_t> client_channel_backup_poll_interval_ms;
+    absl::optional<bool> enable_fork_support;
+    absl::optional<bool> abort_on_leaks;
+    absl::optional<bool> not_use_system_ssl_roots;
+    absl::optional<std::string> experiments;
+    absl::optional<std::string> dns_resolver;
+    absl::optional<std::string> trace;
+    absl::optional<std::string> verbosity;
+    absl::optional<std::string> stacktrace_minloglevel;
+    absl::optional<std::string> poll_strategy;
+    absl::optional<std::string> system_ssl_roots_dir;
+    absl::optional<std::string> default_ssl_roots_file_path;
+    absl::optional<std::string> ssl_cipher_suites;
+  };
+  ConfigVars(const ConfigVars&) = delete;
+  ConfigVars& operator=(const ConfigVars&) = delete;
+  // Get the core configuration; if it does not exist, create it.
+  static const ConfigVars& Get() {
+    auto* p = config_vars_.load(std::memory_order_acquire);
+    if (p != nullptr) return *p;
+    return Load();
+  }
+  static void SetOverrides(const Overrides& overrides);
+  // Drop the config vars. Users must ensure no other threads are
+  // accessing the configuration.
+  static void Reset();
+  std::string ToString() const;
+  // A comma separated list of currently active experiments. Experiments may be
+  // prefixed with a '-' to disable them.
+  absl::string_view Experiments() const { return experiments_; }
+  // Declares the interval in ms between two backup polls on client channels.
+  // These polls are run in the timer thread so that gRPC can process connection
+  // failures while there is no active polling thread. They help reconnect
+  // disconnected client channels (mostly due to idleness), so that the next RPC
+  // on this channel won't fail. Set to 0 to turn off the backup polls.
+  int32_t ClientChannelBackupPollIntervalMs() const {
+    return client_channel_backup_poll_interval_ms_;
+  }
+  // Declares which DNS resolver to use. The default is ares if gRPC is built
+  // with c-ares support. Otherwise, the value of this environment variable is
+  // ignored.
+  absl::string_view DnsResolver() const { return dns_resolver_; }
+  // A comma separated list of tracers that provide additional insight into how
+  // gRPC C core is processing requests via debug logs.
+  absl::string_view Trace() const { return trace_; }
+  // Default gRPC logging verbosity
+  absl::string_view Verbosity() const { return verbosity_; }
+  // Messages logged at the same or higher level than this will print stacktrace
+  absl::string_view StacktraceMinloglevel() const {
+    return stacktrace_minloglevel_;
+  }
+  // Enable fork support
+  bool EnableForkSupport() const { return enable_fork_support_; }
+  // Declares which polling engines to try when starting gRPC. This is a
+  // comma-separated list of engines, which are tried in priority order first ->
+  // last.
+  absl::string_view PollStrategy() const { return poll_strategy_; }
+  // A debugging aid to cause a call to abort() when gRPC objects are leaked
+  // past grpc_shutdown()
+  bool AbortOnLeaks() const { return abort_on_leaks_; }
+  // Custom directory to SSL Roots
+  std::string SystemSslRootsDir() const;
+  // Path to the default SSL roots file.
+  std::string DefaultSslRootsFilePath() const;
+  // Disable loading system root certificates.
+  bool NotUseSystemSslRoots() const { return not_use_system_ssl_roots_; }
+  // A colon separated list of cipher suites to use with OpenSSL
+  absl::string_view SslCipherSuites() const { return ssl_cipher_suites_; }
+
+ private:
+  explicit ConfigVars(const Overrides& overrides);
+  static const ConfigVars& Load();
+  static std::atomic<ConfigVars*> config_vars_;
+  int32_t client_channel_backup_poll_interval_ms_;
+  bool enable_fork_support_;
+  bool abort_on_leaks_;
+  bool not_use_system_ssl_roots_;
+  std::string experiments_;
+  std::string dns_resolver_;
+  std::string trace_;
+  std::string verbosity_;
+  std::string stacktrace_minloglevel_;
+  std::string poll_strategy_;
+  std::string ssl_cipher_suites_;
+  absl::optional<std::string> override_system_ssl_roots_dir_;
+  absl::optional<std::string> override_default_ssl_roots_file_path_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_CONFIG_CONFIG_VARS_H

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

@@ -0,0 +1,51 @@
+// Copyright 2022 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.
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include <atomic>
+#include <string>
+
+#include "src/core/lib/config/config_vars.h"
+
+namespace grpc_core {
+
+std::atomic<ConfigVars*> ConfigVars::config_vars_{nullptr};
+
+const ConfigVars& ConfigVars::Load() {
+  // Called from get, so we know there's no existing config vars.
+  // We might race for them though.
+  auto vars = new ConfigVars({});
+  ConfigVars* expected = nullptr;
+  if (!config_vars_.compare_exchange_strong(expected, vars,
+                                            std::memory_order_acq_rel,
+                                            std::memory_order_acquire)) {
+    delete vars;
+    return *expected;
+  }
+  return *vars;
+}
+
+void ConfigVars::Reset() {
+  delete config_vars_.exchange(nullptr, std::memory_order_acq_rel);
+}
+
+void ConfigVars::SetOverrides(const Overrides& overrides) {
+  delete config_vars_.exchange(new ConfigVars(overrides),
+                               std::memory_order_acq_rel);
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,66 @@
+// Copyright 2022 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.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/config/load_config.h"
+
+#include <stdio.h>
+
+#include "absl/flags/marshalling.h"
+#include "absl/strings/numbers.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/gprpp/env.h"
+
+namespace grpc_core {
+
+namespace {
+absl::optional<std::string> LoadEnv(absl::string_view environment_variable) {
+  return GetEnv(std::string(environment_variable).c_str());
+}
+}  // namespace
+
+std::string LoadConfigFromEnv(absl::string_view environment_variable,
+                              const char* default_value) {
+  return LoadEnv(environment_variable).value_or(default_value);
+}
+
+int32_t LoadConfigFromEnv(absl::string_view environment_variable,
+                          int32_t default_value) {
+  auto env = LoadEnv(environment_variable);
+  if (env.has_value()) {
+    int32_t out;
+    if (absl::SimpleAtoi(*env, &out)) return out;
+    fprintf(stderr, "Error reading int from %s: '%s' is not a number",
+            std::string(environment_variable).c_str(), env->c_str());
+  }
+  return default_value;
+}
+
+bool LoadConfigFromEnv(absl::string_view environment_variable,
+                       bool default_value) {
+  auto env = LoadEnv(environment_variable);
+  if (env.has_value()) {
+    bool out;
+    std::string error;
+    if (absl::ParseFlag(env->c_str(), &out, &error)) return out;
+    fprintf(stderr, "Error reading bool from %s: '%s' is not a bool: %s",
+            std::string(environment_variable).c_str(), env->c_str(),
+            error.c_str());
+  }
+  return default_value;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,49 @@
+// Copyright 2022 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_SRC_CORE_LIB_CONFIG_LOAD_CONFIG_H
+#define GRPC_SRC_CORE_LIB_CONFIG_LOAD_CONFIG_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include <string>
+
+#include "absl/flags/flag.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+namespace grpc_core {
+
+std::string LoadConfigFromEnv(absl::string_view environment_variable,
+                              const char* default_value);
+int32_t LoadConfigFromEnv(absl::string_view environment_variable,
+                          int32_t default_value);
+bool LoadConfigFromEnv(absl::string_view environment_variable,
+                       bool default_value);
+
+template <typename T, typename D>
+T LoadConfig(const absl::Flag<absl::optional<T>>& flag,
+             absl::string_view environment_variable,
+             const absl::optional<T>& override, D default_value) {
+  if (override.has_value()) return *override;
+  auto from_flag = absl::GetFlag(flag);
+  if (from_flag.has_value()) return std::move(*from_flag);
+  return LoadConfigFromEnv(environment_variable, default_value);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_CONFIG_LOAD_CONFIG_H

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

@@ -22,16 +22,16 @@
 
 #include <string.h>
 
+#include <string>
 #include <type_traits>
 
+#include "absl/strings/string_view.h"
+
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-GPR_GLOBAL_CONFIG_DEFINE_STRING(
-    grpc_trace, "",
-    "A comma separated list of tracers that provide additional insight into "
-    "how gRPC C core is processing requests via debug logs.");
+#include "src/core/lib/config/config_vars.h"
 
 int grpc_tracer_set_enabled(const char* name, int enabled);
 
@@ -144,8 +144,7 @@ void grpc_tracer_init(const char* env_var_name) {
 }
 
 void grpc_tracer_init() {
-  grpc_core::UniquePtr<char> value = GPR_GLOBAL_CONFIG_GET(grpc_trace);
-  parse(value.get());
+  parse(std::string(grpc_core::ConfigVars::Get().Trace()).c_str());
 }
 
 int grpc_tracer_set_enabled(const char* name, int enabled) {

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

@@ -23,11 +23,6 @@
 
 #include <atomic>
 
-#include "src/core/lib/gprpp/global_config.h"
-#include "src/core/lib/gprpp/memory.h"
-
-GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_trace);
-
 // TODO(veblush): Remove this deprecated function once codes depending on this
 // function are updated in the internal repo.
 void grpc_tracer_init(const char* env_var_name);

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

@@ -13,13 +13,48 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <grpc/event_engine/event_engine.h>
 
 namespace grpc_event_engine {
 namespace experimental {
 
-constexpr EventEngine::TaskHandle EventEngine::kInvalidTaskHandle;
-constexpr EventEngine::ConnectionHandle EventEngine::kInvalidConnectionHandle;
+constexpr EventEngine::TaskHandle EventEngine::TaskHandle::kInvalid = {-1, -1};
+constexpr EventEngine::ConnectionHandle
+    EventEngine::ConnectionHandle::kInvalid = {-1, -1};
+constexpr EventEngine::DNSResolver::LookupTaskHandle
+    EventEngine::DNSResolver::LookupTaskHandle::kInvalid = {-1, -1};
+
+bool operator==(const EventEngine::TaskHandle& lhs,
+                const EventEngine::TaskHandle& rhs) {
+  return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
+}
+
+bool operator!=(const EventEngine::TaskHandle& lhs,
+                const EventEngine::TaskHandle& rhs) {
+  return !(lhs == rhs);
+}
+
+bool operator==(const EventEngine::ConnectionHandle& lhs,
+                const EventEngine::ConnectionHandle& rhs) {
+  return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
+}
+
+bool operator!=(const EventEngine::ConnectionHandle& lhs,
+                const EventEngine::ConnectionHandle& rhs) {
+  return !(lhs == rhs);
+}
+
+bool operator==(const EventEngine::DNSResolver::LookupTaskHandle& lhs,
+                const EventEngine::DNSResolver::LookupTaskHandle& rhs) {
+  return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
+}
+
+bool operator!=(const EventEngine::DNSResolver::LookupTaskHandle& lhs,
+                const EventEngine::DNSResolver::LookupTaskHandle& rhs) {
+  return !(lhs == rhs);
+}
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -39,34 +39,19 @@ struct TaskHandleComparator {
       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 TaskHandleSet =
+    absl::flat_hash_set<EventEngine::TaskHandle,
+                        TaskHandleComparator<EventEngine::TaskHandle>::Hash>;
 
 using ConnectionHandleSet = absl::flat_hash_set<
-    grpc_event_engine::experimental::EventEngine::ConnectionHandle,
-    TaskHandleComparator<
-        grpc_event_engine::experimental::EventEngine::ConnectionHandle>::Hash,
-    TaskHandleComparator<
-        grpc_event_engine::experimental::EventEngine::ConnectionHandle>::Eq>;
+    EventEngine::ConnectionHandle,
+    TaskHandleComparator<EventEngine::ConnectionHandle>::Hash>;
 
 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>;
+    EventEngine::DNSResolver::LookupTaskHandle,
+    TaskHandleComparator<EventEngine::DNSResolver::LookupTaskHandle>::Hash>;
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -0,0 +1,47 @@
+// Copyright 2023 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_SRC_CORE_LIB_EVENT_ENGINE_MEMORY_ALLOCATOR_FACTORY_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_MEMORY_ALLOCATOR_FACTORY_H
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/memory_allocator.h>
+
+#include "src/core/lib/resource_quota/memory_quota.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class MemoryQuotaBasedMemoryAllocatorFactory : public MemoryAllocatorFactory {
+ public:
+  explicit MemoryQuotaBasedMemoryAllocatorFactory(
+      grpc_core::MemoryQuotaRefPtr memory_quota)
+      : memory_quota_(std::move(memory_quota)) {}
+
+  MemoryAllocator CreateMemoryAllocator(absl::string_view name) override {
+    return memory_quota_->CreateMemoryAllocator(name);
+  }
+
+ private:
+  grpc_core::MemoryQuotaRefPtr memory_quota_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_MEMORY_ALLOCATOR_FACTORY_H

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

@@ -40,7 +40,6 @@
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
 #include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_EV_POLL
@@ -58,14 +57,11 @@
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix_default.h"
 #include "src/core/lib/event_engine/time_util.h"
 #include "src/core/lib/gprpp/fork.h"
-#include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 
-GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_poll_strategy);
-
 static const intptr_t kClosureNotReady = 0;
 static const intptr_t kClosureReady = 1;
 static const int kPollinCheck = POLLIN | POLLHUP | POLLERR;