grpc 1.47.0 → 1.48.0.pre1

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

@@ -0,0 +1,254 @@
+/*
+ *
+ * Copyright 2017 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/iomgr_engine/timer_manager.h"
+
+#include <algorithm>
+#include <memory>
+#include <utility>
+
+#include "absl/memory/memory.h"
+#include "absl/time/time.h"
+#include "absl/types/optional.h"
+
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
+#include "src/core/lib/gprpp/thd.h"
+
+namespace grpc_event_engine {
+namespace iomgr_engine {
+
+namespace {
+class ThreadCollector {
+ public:
+  ThreadCollector() = default;
+  ~ThreadCollector();
+
+  void Collect(std::vector<grpc_core::Thread> threads) {
+    GPR_ASSERT(threads_.empty());
+    threads_ = std::move(threads);
+  }
+
+ private:
+  std::vector<grpc_core::Thread> threads_;
+};
+
+ThreadCollector::~ThreadCollector() {
+  for (auto& t : threads_) t.Join();
+}
+}  // namespace
+
+void TimerManager::StartThread() {
+  ++waiter_count_;
+  ++thread_count_;
+  auto* thread = new RunThreadArgs();
+  thread->self = this;
+  thread->thread =
+      grpc_core::Thread("timer_manager", &TimerManager::RunThread, thread);
+  thread->thread.Start();
+}
+
+void TimerManager::RunSomeTimers(
+    std::vector<experimental::EventEngine::Closure*> timers) {
+  // if there's something to execute...
+  ThreadCollector collector;
+  {
+    grpc_core::MutexLock lock(&mu_);
+    // remove a waiter from the pool, and start another thread if necessary
+    --waiter_count_;
+    if (waiter_count_ == 0) {
+      // The number of timer threads is always increasing until all the threads
+      // are stopped. In rare cases, if a large number of timers fire
+      // simultaneously, we may end up using a large number of threads.
+      // TODO(ctiller): We could avoid this by exiting threads in WaitUntil().
+      StartThread();
+    } else {
+      // if there's no thread waiting with a timeout, kick an existing untimed
+      // waiter so that the next deadline is not missed
+      if (!has_timed_waiter_) {
+        cv_.Signal();
+      }
+    }
+  }
+  for (auto* timer : timers) {
+    timer->Run();
+  }
+  {
+    grpc_core::MutexLock lock(&mu_);
+    collector.Collect(std::move(completed_threads_));
+    // get ready to wait again
+    ++waiter_count_;
+  }
+}
+
+// wait until 'next' (or forever if there is already a timed waiter in the pool)
+// returns true if the thread should continue executing (false if it should
+// shutdown)
+bool TimerManager::WaitUntil(grpc_core::Timestamp next) {
+  grpc_core::MutexLock lock(&mu_);
+
+  if (shutdown_) {
+    return false;
+  }
+
+  // TODO(ctiller): if there are too many waiting threads, this would be a good
+  // place to exit the current thread.
+
+  // If kicked_ is true at this point, it means there was a kick from the timer
+  // system that the timer-manager threads here missed. We cannot trust 'next'
+  // here any longer (since there might be an earlier deadline). So if kicked_
+  // is true at this point, we should quickly exit this and get the next
+  // deadline from the timer system
+
+  if (!kicked_) {
+    // if there's no timed waiter, we should become one: that waiter waits
+    // only until the next timer should expire. All other timers wait forever
+    //
+    // 'timed_waiter_generation_' is a global generation counter. The idea here
+    // is that the thread becoming a timed-waiter increments and stores this
+    // global counter locally in 'my_timed_waiter_generation' before going to
+    // sleep. After waking up, if my_timed_waiter_generation ==
+    // timed_waiter_generation_, it can be sure that it was the timed_waiter
+    // thread (and that no other thread took over while this was asleep)
+    //
+    // Initialize my_timed_waiter_generation to some value that is NOT equal to
+    // timed_waiter_generation_
+    uint64_t my_timed_waiter_generation = timed_waiter_generation_ - 1;
+
+    /* If there's no timed waiter, we should become one: that waiter waits only
+       until the next timer should expire. All other timer threads wait forever
+       unless their 'next' is earlier than the current timed-waiter's deadline
+       (in which case the thread with earlier 'next' takes over as the new timed
+       waiter) */
+    if (next != grpc_core::Timestamp::InfFuture()) {
+      if (!has_timed_waiter_ || (next < timed_waiter_deadline_)) {
+        my_timed_waiter_generation = ++timed_waiter_generation_;
+        has_timed_waiter_ = true;
+        timed_waiter_deadline_ = next;
+      } else {  // timed_waiter_ == true && next >= timed_waiter_deadline_
+        next = grpc_core::Timestamp::InfFuture();
+      }
+    }
+
+    cv_.WaitWithTimeout(&mu_,
+                        absl::Milliseconds((next - host_.Now()).millis()));
+
+    // if this was the timed waiter, then we need to check timers, and flag
+    // that there's now no timed waiter... we'll look for a replacement if
+    // there's work to do after checking timers (code above)
+    if (my_timed_waiter_generation == timed_waiter_generation_) {
+      ++wakeups_;
+      has_timed_waiter_ = false;
+      timed_waiter_deadline_ = grpc_core::Timestamp::InfFuture();
+    }
+  }
+
+  kicked_ = false;
+
+  return true;
+}
+
+void TimerManager::MainLoop() {
+  for (;;) {
+    grpc_core::Timestamp next = grpc_core::Timestamp::InfFuture();
+    absl::optional<std::vector<experimental::EventEngine::Closure*>>
+        check_result = timer_list_->TimerCheck(&next);
+    if (check_result.has_value()) {
+      if (!check_result->empty()) {
+        RunSomeTimers(std::move(*check_result));
+        continue;
+      }
+    } else {
+      /* This case only happens under contention, meaning more than one timer
+         manager thread checked timers concurrently.
+
+         If that happens, we're guaranteed that some other thread has just
+         checked timers, and this will avalanche into some other thread seeing
+         empty timers and doing a timed sleep.
+
+         Consequently, we can just sleep forever here and be happy at some
+         saved wakeup cycles. */
+      next = grpc_core::Timestamp::InfFuture();
+    }
+    if (!WaitUntil(next)) return;
+  }
+}
+
+void TimerManager::RunThread(void* arg) {
+  std::unique_ptr<RunThreadArgs> thread(static_cast<RunThreadArgs*>(arg));
+  thread->self->MainLoop();
+  {
+    grpc_core::MutexLock lock(&thread->self->mu_);
+    thread->self->thread_count_--;
+    thread->self->completed_threads_.push_back(std::move(thread->thread));
+  }
+  thread->self->cv_.Signal();
+}
+
+TimerManager::TimerManager() : host_(this) {
+  timer_list_ = absl::make_unique<TimerList>(&host_);
+  grpc_core::MutexLock lock(&mu_);
+  StartThread();
+}
+
+grpc_core::Timestamp TimerManager::Host::Now() {
+  return grpc_core::Timestamp::FromTimespecRoundDown(
+      gpr_now(GPR_CLOCK_MONOTONIC));
+}
+
+void TimerManager::TimerInit(Timer* timer, grpc_core::Timestamp deadline,
+                             experimental::EventEngine::Closure* closure) {
+  timer_list_->TimerInit(timer, deadline, closure);
+}
+
+bool TimerManager::TimerCancel(Timer* timer) {
+  return timer_list_->TimerCancel(timer);
+}
+
+TimerManager::~TimerManager() {
+  {
+    grpc_core::MutexLock lock(&mu_);
+    shutdown_ = true;
+    cv_.SignalAll();
+  }
+  while (true) {
+    ThreadCollector collector;
+    grpc_core::MutexLock lock(&mu_);
+    collector.Collect(std::move(completed_threads_));
+    if (thread_count_ == 0) break;
+    cv_.Wait(&mu_);
+  }
+}
+
+void TimerManager::Host::Kick() { timer_manager_->Kick(); }
+
+void TimerManager::Kick() {
+  grpc_core::MutexLock lock(&mu_);
+  has_timed_waiter_ = false;
+  timed_waiter_deadline_ = grpc_core::Timestamp::InfFuture();
+  ++timed_waiter_generation_;
+  kicked_ = true;
+  cv_.Signal();
+}
+
+}  // namespace iomgr_engine
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/iomgr_engine/timer_manager.h

@@ -0,0 +1,111 @@
+/*
+ *
+ * Copyright 2017 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_IOMGR_ENGINE_TIMER_MANAGER_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_MANAGER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/iomgr_engine/timer.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/thd.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace iomgr_engine {
+
+// Timer Manager tries to keep only one thread waiting for the next timeout at
+// all times, and thus effectively preventing the thundering herd problem.
+// TODO(ctiller): consider unifying this thread pool and the one in
+// thread_pool.{h,cc}.
+class TimerManager final {
+ public:
+  TimerManager();
+  ~TimerManager();
+
+  grpc_core::Timestamp Now() { return host_.Now(); }
+
+  void TimerInit(Timer* timer, grpc_core::Timestamp deadline,
+                 experimental::EventEngine::Closure* closure);
+  bool TimerCancel(Timer* timer);
+
+ private:
+  struct RunThreadArgs {
+    TimerManager* self;
+    grpc_core::Thread thread;
+  };
+
+  class Host final : public TimerListHost {
+   public:
+    explicit Host(TimerManager* timer_manager)
+        : timer_manager_(timer_manager) {}
+
+    void Kick() override;
+    grpc_core::Timestamp Now() override;
+
+   private:
+    TimerManager* const timer_manager_;
+  };
+
+  void StartThread() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  static void RunThread(void* arg);
+  void MainLoop();
+  void RunSomeTimers(std::vector<experimental::EventEngine::Closure*> timers);
+  bool WaitUntil(grpc_core::Timestamp next);
+  void Kick();
+
+  grpc_core::Mutex mu_;
+  grpc_core::CondVar cv_;
+  Host host_;
+  // number of threads in the system
+  size_t thread_count_ ABSL_GUARDED_BY(mu_) = 0;
+  // number of threads sitting around waiting
+  size_t waiter_count_ ABSL_GUARDED_BY(mu_) = 0;
+  // Threads waiting to be joined
+  std::vector<grpc_core::Thread> completed_threads_ ABSL_GUARDED_BY(mu_);
+  // is there a thread waiting until the next timer should fire?
+  bool has_timed_waiter_ ABSL_GUARDED_BY(mu_) = false;
+  // are we shutting down?
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
+  // are we shutting down?
+  bool kicked_ ABSL_GUARDED_BY(mu_) = false;
+  // the deadline of the current timed waiter thread (only relevant if
+  // has_timed_waiter_ is true)
+  grpc_core::Timestamp timed_waiter_deadline_ ABSL_GUARDED_BY(mu_);
+  // generation counter to track which thread is waiting for the next timer
+  uint64_t timed_waiter_generation_ ABSL_GUARDED_BY(mu_) = 0;
+  // number of timer wakeups
+  uint64_t wakeups_ ABSL_GUARDED_BY(mu_) = 0;
+  // actual timer implementation
+  std::unique_ptr<TimerList> timer_list_;
+};
+
+}  // namespace iomgr_engine
+}  // namespace grpc_event_engine
+
+#endif /* GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_MANAGER_H */

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

@@ -0,0 +1,69 @@
+// 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_PROMISE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_PROMISE_H
+#include <grpc/support/port_platform.h>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// A minimal promise implementation.
+///
+/// This is light-duty, syntactical sugar around cv wait & signal, which is
+/// useful in some cases. A more robust implementation is being worked on
+/// separately.
+template <typename T>
+class Promise {
+ public:
+  // The getter will wait until the setter has been called, and will return the
+  // value passed during Set.
+  T& Get() {
+    grpc_core::MutexLock lock(&mu_);
+    if (!set_) {
+      cv_.Wait(&mu_);
+    }
+    return val_;
+  }
+  // This setter can only be called exactly once without a Reset.
+  // Will automatically unblock getters.
+  void Set(T&& val) {
+    grpc_core::MutexLock lock(&mu_);
+    GPR_ASSERT(!set_);
+    val_ = std::move(val);
+    set_ = true;
+    cv_.SignalAll();
+  }
+
+  // Can only be called after a set operation.
+  void Reset() {
+    grpc_core::MutexLock lock(&mu_);
+    GPR_ASSERT(set_);
+    set_ = false;
+  }
+
+ private:
+  grpc_core::Mutex mu_;
+  grpc_core::CondVar cv_;
+  T val_;
+  bool set_ = false;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_PROMISE_H

data/src/core/lib/gpr/time_posix.cc

@@ -88,17 +88,14 @@ static gpr_timespec now_impl(gpr_clock_type clock_type) {
 #include <mach/mach_time.h>
 #include <sys/time.h>
 
-static double g_time_scale;
-static uint64_t g_time_start;
-
-void gpr_time_init(void) {
+static double g_time_scale = []() {
   mach_timebase_info_data_t tb = {0, 1};
-  gpr_precise_clock_init();
   mach_timebase_info(&tb);
-  g_time_scale = tb.numer;
-  g_time_scale /= tb.denom;
-  g_time_start = mach_absolute_time();
-}
+  return static_cast<double>(tb.numer) / static_cast<double>(tb.denom);
+}();
+static uint64_t g_time_start = mach_absolute_time();
+
+void gpr_time_init(void) { gpr_precise_clock_init(); }
 
 static gpr_timespec now_impl(gpr_clock_type clock) {
   gpr_timespec now;

data/src/core/lib/gpr/time_windows.cc

@@ -31,15 +31,18 @@
 
 #include "src/core/lib/gpr/time_precise.h"
 
-static LARGE_INTEGER g_start_time;
-static double g_time_scale;
-
-void gpr_time_init(void) {
+static LARGE_INTEGER g_start_time = []() {
+  LARGE_INTEGER x;
+  QueryPerformanceCounter(&x);
+  return x;
+}();
+static double g_time_scale = []() {
   LARGE_INTEGER frequency;
   QueryPerformanceFrequency(&frequency);
-  QueryPerformanceCounter(&g_start_time);
-  g_time_scale = 1.0 / (double)frequency.QuadPart;
-}
+  return 1.0 / (double)frequency.QuadPart;
+}();
+
+void gpr_time_init(void) {}
 
 static gpr_timespec now_impl(gpr_clock_type clock) {
   gpr_timespec now_tv;

data/src/core/lib/gprpp/manual_constructor.h

@@ -25,12 +25,9 @@
 
 #include <stddef.h>
 
-#include <new>
 #include <type_traits>
 #include <utility>
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/gprpp/construct_destruct.h"
 
 namespace grpc_core {
@@ -102,70 +99,6 @@ class max_align_of<A, B...> {
 
 }  // namespace manual_ctor_impl
 
-template <class BaseType, class... DerivedTypes>
-class PolymorphicManualConstructor {
- public:
-  // No constructor or destructor because one of the most useful uses of
-  // this class is as part of a union, and members of a union could not have
-  // constructors or destructors till C++11.  And, anyway, the whole point of
-  // this class is to bypass constructor and destructor.
-
-  BaseType* get() { return reinterpret_cast<BaseType*>(&space_); }
-  const BaseType* get() const {
-    return reinterpret_cast<const BaseType*>(&space_);
-  }
-
-  BaseType* operator->() { return get(); }
-  const BaseType* operator->() const { return get(); }
-
-  BaseType& operator*() { return *get(); }
-  const BaseType& operator*() const { return *get(); }
-
-  template <class DerivedType>
-  void Init() {
-    FinishInit(new (&space_) DerivedType);
-  }
-
-  // Init() constructs the Type instance using the given arguments
-  // (which are forwarded to Type's constructor).
-  //
-  // Note that Init() with no arguments performs default-initialization,
-  // not zero-initialization (i.e it behaves the same as "new Type;", not
-  // "new Type();"), so it will leave non-class types uninitialized.
-  template <class DerivedType, typename... Ts>
-  void Init(Ts&&... args) {
-    FinishInit(new (&space_) DerivedType(std::forward<Ts>(args)...));
-  }
-
-  // Init() that is equivalent to copy and move construction.
-  // Enables usage like this:
-  //   ManualConstructor<std::vector<int>> v;
-  //   v.Init({1, 2, 3});
-  template <class DerivedType>
-  void Init(const DerivedType& x) {
-    FinishInit(new (&space_) DerivedType(x));
-  }
-  template <class DerivedType>
-  void Init(DerivedType&& x) {
-    FinishInit(new (&space_) DerivedType(std::forward<DerivedType>(x)));
-  }
-
-  void Destroy() { get()->~BaseType(); }
-
- private:
-  template <class DerivedType>
-  void FinishInit(DerivedType* p) {
-    static_assert(
-        manual_ctor_impl::is_one_of<DerivedType, DerivedTypes...>::value,
-        "DerivedType must be one of the predeclared DerivedTypes");
-    GPR_ASSERT(static_cast<BaseType*>(p) == p);
-  }
-
-  typename std::aligned_storage<
-      manual_ctor_impl::max_size_of<DerivedTypes...>::value,
-      manual_ctor_impl::max_align_of<DerivedTypes...>::value>::type space_;
-};
-
 template <typename Type>
 class ManualConstructor {
  public: