grpc 1.54.2 → 1.56.0.pre3

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

@@ -38,15 +38,15 @@ class ConfigVars {
     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;
+    absl::optional<std::string> experiments;
+    absl::optional<std::string> trace;
   };
   ConfigVars(const ConfigVars&) = delete;
   ConfigVars& operator=(const ConfigVars&) = delete;
@@ -111,13 +111,13 @@ class ConfigVars {
   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_;
+  std::string experiments_;
+  std::string trace_;
   absl::optional<std::string> override_system_ssl_roots_dir_;
   absl::optional<std::string> override_default_ssl_roots_file_path_;
 };

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

@@ -20,8 +20,10 @@
 
 #include "absl/flags/marshalling.h"
 #include "absl/strings/numbers.h"
+#include "absl/strings/str_join.h"
 #include "absl/types/optional.h"
 
+#include "src/core/lib/gpr/log_internal.h"
 #include "src/core/lib/gprpp/env.h"
 
 namespace grpc_core {
@@ -34,6 +36,7 @@ absl::optional<std::string> LoadEnv(absl::string_view environment_variable) {
 
 std::string LoadConfigFromEnv(absl::string_view environment_variable,
                               const char* default_value) {
+  GPR_ASSERT_INTERNAL(!environment_variable.empty());
   return LoadEnv(environment_variable).value_or(default_value);
 }
 
@@ -63,4 +66,14 @@ bool LoadConfigFromEnv(absl::string_view environment_variable,
   return default_value;
 }
 
+std::string LoadConfig(const absl::Flag<std::vector<std::string>>& flag,
+                       absl::string_view environment_variable,
+                       const absl::optional<std::string>& override,
+                       const char* default_value) {
+  if (override.has_value()) return *override;
+  auto from_flag = absl::GetFlag(flag);
+  if (!from_flag.empty()) return absl::StrJoin(from_flag, ",");
+  return LoadConfigFromEnv(environment_variable, default_value);
+}
+
 }  // namespace grpc_core

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

@@ -20,6 +20,7 @@
 #include <stdint.h>
 
 #include <string>
+#include <vector>
 
 #include "absl/flags/flag.h"
 #include "absl/strings/string_view.h"
@@ -44,6 +45,11 @@ T LoadConfig(const absl::Flag<absl::optional<T>>& flag,
   return LoadConfigFromEnv(environment_variable, default_value);
 }
 
+std::string LoadConfig(const absl::Flag<std::vector<std::string>>& flag,
+                       absl::string_view environment_variable,
+                       const absl::optional<std::string>& override,
+                       const char* default_value);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_CONFIG_LOAD_CONFIG_H

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

@@ -71,7 +71,7 @@ class EventLog {
   std::vector<Entry> EndCollection(
       absl::Span<const absl::string_view> wanted_events);
 
-  PerCpu<Fragment> fragments_;
+  PerCpu<Fragment> fragments_{PerCpuOptions().SetCpusPerShard(2)};
   gpr_cycle_counter collection_begin_;
   static std::atomic<EventLog*> g_instance_;
 };

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

@@ -294,7 +294,7 @@ class GlobalStatsCollector {
     HistogramCollector_16777216_20 http2_send_message_size;
     HistogramCollector_65536_26 http2_metadata_size;
   };
-  PerCpu<Data> data_;
+  PerCpu<Data> data_{PerCpuOptions().SetCpusPerShard(4).SetMaxShards(32)};
 };
 }  // namespace grpc_core
 

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

@@ -20,15 +20,16 @@
 
 #include "src/core/lib/debug/trace.h"
 
-#include <string.h>
-
 #include <string>
 #include <type_traits>
+#include <utility>
 
+#include "absl/strings/ascii.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/config/config_vars.h"
@@ -39,31 +40,31 @@ namespace grpc_core {
 
 TraceFlag* TraceFlagList::root_tracer_ = nullptr;
 
-bool TraceFlagList::Set(const char* name, bool enabled) {
+bool TraceFlagList::Set(absl::string_view name, bool enabled) {
   TraceFlag* t;
-  if (0 == strcmp(name, "all")) {
+  if (name == "all") {
     for (t = root_tracer_; t; t = t->next_tracer_) {
       t->set_enabled(enabled);
     }
-  } else if (0 == strcmp(name, "list_tracers")) {
+  } else if (name == "list_tracers") {
     LogAllTracers();
-  } else if (0 == strcmp(name, "refcount")) {
+  } else if (name == "refcount") {
     for (t = root_tracer_; t; t = t->next_tracer_) {
-      if (strstr(t->name_, "refcount") != nullptr) {
+      if (absl::StrContains(t->name_, "refcount")) {
         t->set_enabled(enabled);
       }
     }
   } else {
     bool found = false;
     for (t = root_tracer_; t; t = t->next_tracer_) {
-      if (0 == strcmp(name, t->name_)) {
+      if (name == t->name_) {
         t->set_enabled(enabled);
         found = true;
       }
     }
     // check for unknowns, but ignore "", to allow to GRPC_TRACE=
-    if (!found && 0 != strcmp(name, "")) {
-      gpr_log(GPR_ERROR, "Unknown trace var: '%s'", name);
+    if (!found && !name.empty()) {
+      gpr_log(GPR_ERROR, "Unknown trace var: '%s'", std::string(name).c_str());
       return false;  // early return
     }
   }
@@ -77,12 +78,17 @@ void TraceFlagList::Add(TraceFlag* flag) {
 
 void TraceFlagList::LogAllTracers() {
   gpr_log(GPR_DEBUG, "available tracers:");
-  TraceFlag* t;
-  for (t = root_tracer_; t != nullptr; t = t->next_tracer_) {
+  for (TraceFlag* t = root_tracer_; t != nullptr; t = t->next_tracer_) {
     gpr_log(GPR_DEBUG, "\t%s", t->name_);
   }
 }
 
+void TraceFlagList::SaveTo(std::map<std::string, bool>& values) {
+  for (TraceFlag* t = root_tracer_; t != nullptr; t = t->next_tracer_) {
+    values[t->name_] = t->enabled();
+  }
+}
+
 // Flags register themselves on the list during construction
 TraceFlag::TraceFlag(bool default_enabled, const char* name) : name_(name) {
   static_assert(std::is_trivially_destructible<TraceFlag>::value,
@@ -91,60 +97,32 @@ TraceFlag::TraceFlag(bool default_enabled, const char* name) : name_(name) {
   TraceFlagList::Add(this);
 }
 
-}  // namespace grpc_core
-
-static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
-  size_t n = *ns;
-  size_t np = n + 1;
-  char* s;
-  size_t len;
-  GPR_ASSERT(end >= beg);
-  len = static_cast<size_t>(end - beg);
-  s = static_cast<char*>(gpr_malloc(len + 1));
-  memcpy(s, beg, len);
-  s[len] = 0;
-  *ss = static_cast<char**>(gpr_realloc(*ss, sizeof(char**) * np));
-  (*ss)[n] = s;
-  *ns = np;
-}
+SavedTraceFlags::SavedTraceFlags() { TraceFlagList::SaveTo(values_); }
 
-static void split(const char* s, char*** ss, size_t* ns) {
-  const char* c = strchr(s, ',');
-  if (c == nullptr) {
-    add(s, s + strlen(s), ss, ns);
-  } else {
-    add(s, c, ss, ns);
-    split(c + 1, ss, ns);
+void SavedTraceFlags::Restore() {
+  for (const auto& flag : values_) {
+    TraceFlagList::Set(flag.first, flag.second);
   }
 }
 
-static void parse(const char* s) {
-  char** strings = nullptr;
-  size_t nstrings = 0;
-  size_t i;
-  split(s, &strings, &nstrings);
-
-  for (i = 0; i < nstrings; i++) {
-    if (strings[i][0] == '-') {
-      grpc_core::TraceFlagList::Set(strings[i] + 1, false);
+namespace {
+void ParseTracers(absl::string_view tracers) {
+  for (auto s : absl::StrSplit(tracers, ',')) {
+    s = absl::StripAsciiWhitespace(s);
+    if (s.empty()) continue;
+    if (s[0] == '-') {
+      TraceFlagList::Set(s.substr(1), false);
     } else {
-      grpc_core::TraceFlagList::Set(strings[i], true);
+      TraceFlagList::Set(s, true);
     }
   }
-
-  for (i = 0; i < nstrings; i++) {
-    gpr_free(strings[i]);
-  }
-  gpr_free(strings);
 }
+}  // namespace
 
-void grpc_tracer_init(const char* env_var_name) {
-  (void)env_var_name;  // suppress unused variable error
-  grpc_tracer_init();
-}
+}  // namespace grpc_core
 
 void grpc_tracer_init() {
-  parse(std::string(grpc_core::ConfigVars::Get().Trace()).c_str());
+  grpc_core::ParseTracers(grpc_core::ConfigVars::Get().Trace());
 }
 
 int grpc_tracer_set_enabled(const char* name, int enabled) {

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

@@ -22,10 +22,10 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
+#include <map>
+#include <string>
 
-// 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);
+#include "absl/strings/string_view.h"
 
 void grpc_tracer_init();
 void grpc_tracer_shutdown(void);
@@ -35,8 +35,9 @@ namespace grpc_core {
 class TraceFlag;
 class TraceFlagList {
  public:
-  static bool Set(const char* name, bool enabled);
+  static bool Set(absl::string_view name, bool enabled);
   static void Add(TraceFlag* flag);
+  static void SaveTo(std::map<std::string, bool>& values);
 
  private:
   static void LogAllTracers();
@@ -101,6 +102,15 @@ class DebugOnlyTraceFlag {
 };
 #endif
 
+class SavedTraceFlags {
+ public:
+  SavedTraceFlags();
+  void Restore();
+
+ private:
+  std::map<std::string, bool> values_;
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_DEBUG_TRACE_H

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

@@ -0,0 +1,211 @@
+// 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.
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_APPLE
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <grpc/support/cpu.h>
+
+#include "src/core/lib/event_engine/cf_engine/cf_engine.h"
+#include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/thread_pool/thread_pool.h"
+#include "src/core/lib/event_engine/trace.h"
+#include "src/core/lib/event_engine/utils.h"
+#include "src/core/lib/gprpp/crash.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+struct CFEventEngine::Closure final : public EventEngine::Closure {
+  absl::AnyInvocable<void()> cb;
+  Timer timer;
+  CFEventEngine* engine;
+  EventEngine::TaskHandle handle;
+
+  void Run() override {
+    GRPC_EVENT_ENGINE_TRACE("CFEventEngine:%p executing callback:%s", engine,
+                            HandleToString(handle).c_str());
+    {
+      grpc_core::MutexLock lock(&engine->task_mu_);
+      engine->known_handles_.erase(handle);
+    }
+    cb();
+    delete this;
+  }
+};
+
+CFEventEngine::CFEventEngine()
+    : thread_pool_(
+          MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
+      timer_manager_(thread_pool_) {}
+
+CFEventEngine::~CFEventEngine() {
+  {
+    grpc_core::MutexLock lock(&task_mu_);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+      for (auto handle : known_handles_) {
+        gpr_log(GPR_ERROR,
+                "CFEventEngine:%p uncleared TaskHandle at shutdown:%s", this,
+                HandleToString(handle).c_str());
+      }
+    }
+    GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+    timer_manager_.Shutdown();
+  }
+  thread_pool_->Quiesce();
+}
+
+absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
+CFEventEngine::CreateListener(
+    Listener::AcceptCallback /* on_accept */,
+    absl::AnyInvocable<void(absl::Status)> /* on_shutdown */,
+    const EndpointConfig& /* config */,
+    std::unique_ptr<MemoryAllocatorFactory> /* memory_allocator_factory */) {
+  grpc_core::Crash("unimplemented");
+}
+
+CFEventEngine::ConnectionHandle CFEventEngine::Connect(
+    OnConnectCallback on_connect, const ResolvedAddress& addr,
+    const EndpointConfig& /* args */, MemoryAllocator memory_allocator,
+    Duration timeout) {
+  auto endpoint_ptr = new CFStreamEndpoint(
+      std::static_pointer_cast<CFEventEngine>(shared_from_this()),
+      std::move(memory_allocator));
+
+  ConnectionHandle handle{reinterpret_cast<intptr_t>(endpoint_ptr), 0};
+  {
+    grpc_core::MutexLock lock(&conn_mu_);
+    conn_handles_.insert(handle);
+  }
+
+  auto deadline_timer =
+      RunAfter(timeout, [handle, that = std::static_pointer_cast<CFEventEngine>(
+                                     shared_from_this())]() {
+        that->CancelConnectInternal(
+            handle, absl::DeadlineExceededError("Connect timed out"));
+      });
+
+  auto on_connect2 =
+      [that = std::static_pointer_cast<CFEventEngine>(shared_from_this()),
+       deadline_timer, handle,
+       on_connect = std::move(on_connect)](absl::Status status) mutable {
+        // best effort canceling deadline timer
+        that->Cancel(deadline_timer);
+
+        {
+          grpc_core::MutexLock lock(&that->conn_mu_);
+          that->conn_handles_.erase(handle);
+        }
+
+        auto endpoint_ptr = reinterpret_cast<CFStreamEndpoint*>(handle.keys[0]);
+
+        if (!status.ok()) {
+          on_connect(std::move(status));
+          delete endpoint_ptr;
+          return;
+        }
+
+        on_connect(std::unique_ptr<EventEngine::Endpoint>(endpoint_ptr));
+      };
+
+  endpoint_ptr->Connect(std::move(on_connect2), addr);
+
+  return handle;
+}
+
+bool CFEventEngine::CancelConnect(ConnectionHandle handle) {
+  CancelConnectInternal(handle, absl::CancelledError("CancelConnect"));
+  // on_connect will always be called, even if cancellation is successful
+  return false;
+}
+
+bool CFEventEngine::CancelConnectInternal(ConnectionHandle handle,
+                                          absl::Status status) {
+  grpc_core::MutexLock lock(&conn_mu_);
+
+  if (!conn_handles_.contains(handle)) {
+    GRPC_EVENT_ENGINE_TRACE(
+        "Unknown connection handle: %s",
+        HandleToString<EventEngine::ConnectionHandle>(handle).c_str());
+    return false;
+  }
+  conn_handles_.erase(handle);
+
+  // keep the `conn_mu_` lock to prevent endpoint_ptr from being deleted
+
+  auto endpoint_ptr = reinterpret_cast<CFStreamEndpoint*>(handle.keys[0]);
+  return endpoint_ptr->CancelConnect(status);
+}
+
+bool CFEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
+
+std::unique_ptr<EventEngine::DNSResolver> CFEventEngine::GetDNSResolver(
+    const DNSResolver::ResolverOptions& /* options */) {
+  grpc_core::Crash("unimplemented");
+}
+
+void CFEventEngine::Run(EventEngine::Closure* closure) {
+  thread_pool_->Run(closure);
+}
+
+void CFEventEngine::Run(absl::AnyInvocable<void()> closure) {
+  thread_pool_->Run(std::move(closure));
+}
+
+EventEngine::TaskHandle CFEventEngine::RunAfter(Duration when,
+                                                EventEngine::Closure* closure) {
+  return RunAfterInternal(when, [closure]() { closure->Run(); });
+}
+
+EventEngine::TaskHandle CFEventEngine::RunAfter(
+    Duration when, absl::AnyInvocable<void()> closure) {
+  return RunAfterInternal(when, std::move(closure));
+}
+
+bool CFEventEngine::Cancel(TaskHandle handle) {
+  grpc_core::MutexLock lock(&task_mu_);
+  if (!known_handles_.contains(handle)) return false;
+  auto* cd = reinterpret_cast<Closure*>(handle.keys[0]);
+  bool r = timer_manager_.TimerCancel(&cd->timer);
+  known_handles_.erase(handle);
+  if (r) delete cd;
+  return r;
+}
+
+EventEngine::TaskHandle CFEventEngine::RunAfterInternal(
+    Duration when, absl::AnyInvocable<void()> cb) {
+  auto when_ts = ToTimestamp(timer_manager_.Now(), when);
+  auto* cd = new Closure;
+  cd->cb = std::move(cb);
+  cd->engine = this;
+  EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
+                                 aba_token_.fetch_add(1)};
+  grpc_core::MutexLock lock(&task_mu_);
+  known_handles_.insert(handle);
+  cd->handle = handle;
+  GRPC_EVENT_ENGINE_TRACE("CFEventEngine:%p scheduling callback:%s", this,
+                          HandleToString(handle).c_str());
+  timer_manager_.TimerInit(&cd->timer, when_ts, cd);
+  return handle;
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_APPLE

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

@@ -0,0 +1,86 @@
+// 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_CF_ENGINE_CF_ENGINE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CF_ENGINE_H
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_APPLE
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/handle_containers.h"
+#include "src/core/lib/event_engine/posix_engine/event_poller.h"
+#include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
+#include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/surface/init_internally.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class CFEventEngine : public EventEngine,
+                      public Scheduler,
+                      public grpc_core::KeepsGrpcInitialized {
+ public:
+  CFEventEngine();
+  ~CFEventEngine() override;
+
+  absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
+      Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
+      override;
+
+  ConnectionHandle Connect(OnConnectCallback on_connect,
+                           const ResolvedAddress& addr,
+                           const EndpointConfig& args,
+                           MemoryAllocator memory_allocator,
+                           Duration timeout) override;
+  bool CancelConnect(ConnectionHandle handle) override;
+  bool IsWorkerThread() override;
+  std::unique_ptr<DNSResolver> GetDNSResolver(
+      const DNSResolver::ResolverOptions& options) override;
+  void Run(Closure* closure) override;
+  void Run(absl::AnyInvocable<void()> closure) override;
+  TaskHandle RunAfter(Duration when, Closure* closure) override;
+  TaskHandle RunAfter(Duration when,
+                      absl::AnyInvocable<void()> closure) override;
+  bool Cancel(TaskHandle handle) override;
+
+ private:
+  struct Closure;
+  EventEngine::TaskHandle RunAfterInternal(Duration when,
+                                           absl::AnyInvocable<void()> cb);
+
+  bool CancelConnectInternal(ConnectionHandle handle, absl::Status status);
+
+  grpc_core::Mutex task_mu_;
+  TaskHandleSet known_handles_ ABSL_GUARDED_BY(task_mu_);
+  std::atomic<intptr_t> aba_token_{0};
+
+  grpc_core::Mutex conn_mu_;
+  ConnectionHandleSet conn_handles_ ABSL_GUARDED_BY(conn_mu_);
+
+  std::shared_ptr<ThreadPool> thread_pool_;
+  TimerManager timer_manager_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_APPLE
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CF_ENGINE_H