grpc 1.48.0 → 1.50.0

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

@@ -17,24 +17,30 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
 #include <grpc/event_engine/endpoint_config.h>
-#include <grpc/impl/codegen/grpc_types.h>
+
+#include "src/core/lib/channel/channel_args.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-/// A readonly \a EndpointConfig based on grpc_channel_args. This class does not
-/// take ownership of the grpc_endpoint_args*, and instances of this class
-/// should not be used after the underlying args are destroyed.
 class ChannelArgsEndpointConfig : public EndpointConfig {
  public:
-  explicit ChannelArgsEndpointConfig(const grpc_channel_args* args)
+  ChannelArgsEndpointConfig() = default;
+  explicit ChannelArgsEndpointConfig(const grpc_core::ChannelArgs& args)
       : args_(args) {}
-  Setting Get(absl::string_view key) const override;
+  ChannelArgsEndpointConfig(const ChannelArgsEndpointConfig& config) = default;
+  ChannelArgsEndpointConfig& operator=(const ChannelArgsEndpointConfig& other) =
+      default;
+  absl::optional<int> GetInt(absl::string_view key) const override;
+  absl::optional<absl::string_view> GetString(
+      absl::string_view key) const override;
+  void* GetVoidPointer(absl::string_view key) const override;
 
  private:
-  const grpc_channel_args* args_;
+  grpc_core::ChannelArgs args_;
 };
 
 }  // namespace experimental

data/src/core/lib/event_engine/{event_engine.cc → default_event_engine.cc}

@@ -13,28 +13,32 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/event_engine/default_event_engine.h"
+
 #include <atomic>
-#include <functional>
 #include <memory>
 #include <utility>
 
+#include "absl/functional/any_invocable.h"
+
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/event_engine_factory.h"
+#include "src/core/lib/event_engine/default_event_engine_factory.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
 namespace {
-std::atomic<const std::function<std::unique_ptr<EventEngine>()>*>
+std::atomic<absl::AnyInvocable<std::unique_ptr<EventEngine>()>*>
     g_event_engine_factory{nullptr};
 std::atomic<EventEngine*> g_event_engine{nullptr};
 }  // namespace
 
 void SetDefaultEventEngineFactory(
-    std::function<std::unique_ptr<EventEngine>()> factory) {
+    absl::AnyInvocable<std::unique_ptr<EventEngine>()> factory) {
   delete g_event_engine_factory.exchange(
-      new std::function<std::unique_ptr<EventEngine>()>(std::move(factory)));
+      new absl::AnyInvocable<std::unique_ptr<EventEngine>()>(
+          std::move(factory)));
 }
 
 std::unique_ptr<EventEngine> CreateEventEngine() {

data/src/core/lib/event_engine/{event_engine_factory.h → default_event_engine.h}

@@ -11,12 +11,11 @@
 // 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_EVENT_ENGINE_FACTORY_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H
 
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H
 
-#include <memory>
+#include <grpc/support/port_platform.h>
 
 #include <grpc/event_engine/event_engine.h>
 
@@ -29,13 +28,10 @@ namespace experimental {
 /// Strongly consider whether you could use \a CreateEventEngine instead.
 EventEngine* GetDefaultEventEngine();
 
-/// Create an EventEngine using the default factory provided at link time.
-std::unique_ptr<EventEngine> DefaultEventEngineFactory();
-
 /// Reset the default event engine
 void ResetDefaultEventEngine();
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H

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

@@ -11,23 +11,40 @@
 // 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/event_engine/default_event_engine_factory.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/iomgr_engine.h"
+#ifdef GPR_WINDOWS
+#include "src/core/lib/event_engine/windows/windows_engine.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
+  return absl::make_unique<WindowsEventEngine>();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+#else  // not GPR_WINDOWS
+#include "src/core/lib/event_engine/posix_engine/posix_engine.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
 std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
-  return absl::make_unique<IomgrEventEngine>();
+  return absl::make_unique<PosixEventEngine>();
 }
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
+
+#endif

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

@@ -0,0 +1,33 @@
+// Copyright 2021 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_DEFAULT_EVENT_ENGINE_FACTORY_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_FACTORY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// Create an EventEngine using the default factory provided at link time.
+std::unique_ptr<EventEngine> DefaultEventEngineFactory();
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_FACTORY_H

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

@@ -0,0 +1,38 @@
+// 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_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// A subset of the EventEngine execution API. See event_engine.h for details
+class Executor {
+ public:
+  virtual ~Executor() = default;
+  virtual void Run(EventEngine::Closure* closure) = 0;
+  virtual void Run(absl::AnyInvocable<void()> closure) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H

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

@@ -0,0 +1,36 @@
+// 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/event_engine/executor/threaded_executor.h"
+
+#include <utility>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+ThreadedExecutor::ThreadedExecutor(int reserve_threads)
+    : thread_pool_(reserve_threads){};
+
+void ThreadedExecutor::Run(EventEngine::Closure* closure) {
+  thread_pool_.Add([closure]() { closure->Run(); });
+}
+
+void ThreadedExecutor::Run(absl::AnyInvocable<void()> closure) {
+  thread_pool_.Add(std::move(closure));
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/executor/threaded_executor.h

@@ -0,0 +1,44 @@
+// 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_CORE_LIB_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/executor/executor.h"
+#include "src/core/lib/event_engine/thread_pool.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class ThreadedExecutor : public Executor {
+ public:
+  explicit ThreadedExecutor(int reserve_threads);
+  ~ThreadedExecutor() override = default;
+  void Run(EventEngine::Closure* closure) override;
+  void Run(absl::AnyInvocable<void()> closure) override;
+
+ private:
+  ThreadPool thread_pool_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H

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

@@ -0,0 +1,101 @@
+// 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/event_engine/forkable.h"
+
+#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
+#include <pthread.h>
+
+#include "absl/container/flat_hash_set.h"
+
+#include "src/core/lib/gprpp/no_destruct.h"
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+grpc_core::NoDestruct<grpc_core::Mutex> g_mu;
+bool g_registered ABSL_GUARDED_BY(g_mu){false};
+grpc_core::NoDestruct<absl::flat_hash_set<Forkable*>> g_forkables
+    ABSL_GUARDED_BY(g_mu);
+}  // namespace
+
+Forkable::Forkable() { ManageForkable(this); }
+
+Forkable::~Forkable() { StopManagingForkable(this); }
+
+void RegisterForkHandlers() {
+  grpc_core::MutexLock lock(g_mu.get());
+  if (!std::exchange(g_registered, true)) {
+    pthread_atfork(PrepareFork, PostforkParent, PostforkChild);
+  }
+};
+
+void PrepareFork() {
+  grpc_core::MutexLock lock(g_mu.get());
+  for (auto* forkable : *g_forkables) {
+    forkable->PrepareFork();
+  }
+}
+void PostforkParent() {
+  grpc_core::MutexLock lock(g_mu.get());
+  for (auto* forkable : *g_forkables) {
+    forkable->PostforkParent();
+  }
+}
+
+void PostforkChild() {
+  grpc_core::MutexLock lock(g_mu.get());
+  for (auto* forkable : *g_forkables) {
+    forkable->PostforkChild();
+  }
+}
+
+void ManageForkable(Forkable* forkable) {
+  grpc_core::MutexLock lock(g_mu.get());
+  g_forkables->insert(forkable);
+}
+
+void StopManagingForkable(Forkable* forkable) {
+  grpc_core::MutexLock lock(g_mu.get());
+  g_forkables->erase(forkable);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#else  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+
+namespace grpc_event_engine {
+namespace experimental {
+
+Forkable::Forkable() {}
+Forkable::~Forkable() {}
+
+void RegisterForkHandlers() {}
+void PrepareFork() {}
+void PostforkParent() {}
+void PostforkChild() {}
+
+void ManageForkable(Forkable* /* forkable */) {}
+void StopManagingForkable(Forkable* /* forkable */) {}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK

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

@@ -0,0 +1,61 @@
+// 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_CORE_LIB_EVENT_ENGINE_FORKABLE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
+
+#include <grpc/support/port_platform.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Register fork handlers with the system, enabling fork support.
+//
+// This provides pthread-based support for fork events. Any objects that
+// implement Forkable can register themselves with this system using
+// ManageForkable, and their respective methods will be called upon fork.
+//
+// This should be called once upon grpc_initialization.
+void RegisterForkHandlers();
+
+// Global callback for pthread_atfork's *prepare argument
+void PrepareFork();
+// Global callback for pthread_atfork's *parent argument
+void PostforkParent();
+// Global callback for pthread_atfork's *child argument
+void PostforkChild();
+
+// An interface to be implemented by EventEngines that wish to have managed fork
+// support.
+class Forkable {
+ public:
+  Forkable();
+  virtual ~Forkable();
+  virtual void PrepareFork() = 0;
+  virtual void PostforkParent() = 0;
+  virtual void PostforkChild() = 0;
+};
+
+// Add Forkables from the set of objects that are supported.
+// Upon fork, each forkable will have its respective fork hooks called on
+// the thread that invoked the fork.
+//
+// Relative ordering of fork callback operations is not guaranteed.
+void ManageForkable(Forkable* forkable);
+// Remove a forkable from the managed set.
+void StopManagingForkable(Forkable* forkable);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H

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

@@ -0,0 +1,56 @@
+// 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_CORE_LIB_EVENT_ENGINE_POLLER_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POLLER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/function_ref.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// A generic cross-platform "poller" concept.
+// Concrete implementations will likely manage a set of sockets/file
+// descriptors/etc, allowing threads to drive polling and event processing via
+// Work(...).
+class Poller {
+ public:
+  enum class WorkResult { kOk, kDeadlineExceeded, kKicked };
+
+  virtual ~Poller() = default;
+  // Poll once for events and process received events. The callback function
+  // "schedule_poll_again" is expected to be run synchronously prior to
+  // processing received events. The callback's responsibility primarily is to
+  // schedule Poller::Work asynchronously again. This would ensure that the next
+  // polling cycle would run as quickly as possible to ensure continuous
+  // polling.
+  //
+  // Returns:
+  //  * Poller::WorkResult::kKicked if it was Kicked.
+  //  * Poller::WorkResult::kDeadlineExceeded if timeout occurred
+  //  * Poller::WorkResult::kOk, otherwise indicating that the callback function
+  //  was run synchonously before some events were processed.
+  virtual WorkResult Work(EventEngine::Duration timeout,
+                          absl::FunctionRef<void()> schedule_poll_again) = 0;
+  // Trigger the threads executing Work(..) to break out as soon as possible.
+  virtual void Kick() = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POLLER_H