grpc 1.47.0 → 1.48.0.pre1

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

@@ -13,60 +13,59 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/event_engine/iomgr_engine.h"
+#include "src/core/lib/event_engine/iomgr_engine/iomgr_engine.h"
 
+#include <algorithm>
 #include <string>
-#include <type_traits>
 #include <utility>
 
-#include "absl/cleanup/cleanup.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/strings/str_cat.h"
-#include "absl/time/clock.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/iomgr_engine/timer.h"
 #include "src/core/lib/event_engine/trace.h"
-#include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/time.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/executor.h"
-#include "src/core/lib/iomgr/timer.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
 namespace {
 
-struct ClosureData {
-  grpc_timer timer;
-  grpc_closure closure;
-  absl::variant<std::function<void()>, EventEngine::Closure*> cb;
-  IomgrEventEngine* engine;
-  EventEngine::TaskHandle handle;
-};
-
-// Timer limits due to quirks in the iomgr implementation.
-// If deadline <= Now, the callback will be run inline, which can result in lock
-// issues. And absl::InfiniteFuture yields UB.
-absl::Time Clamp(absl::Time when) {
-  absl::Time max = absl::Now() + absl::Hours(8766);
-  absl::Time min = absl::Now() + absl::Milliseconds(2);
-  if (when > max) return max;
-  if (when < min) return min;
-  return when;
-}
-
 std::string HandleToString(EventEngine::TaskHandle handle) {
   return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
 }
 
 }  // namespace
 
+grpc_core::Timestamp IomgrEventEngine::ToTimestamp(EventEngine::Duration when) {
+  return timer_manager_.Now() +
+         std::max(grpc_core::Duration::Milliseconds(1),
+                  grpc_core::Duration::NanosecondsRoundUp(when.count())) +
+         grpc_core::Duration::Milliseconds(1);
+}
+
+struct IomgrEventEngine::ClosureData final : public EventEngine::Closure {
+  std::function<void()> cb;
+  iomgr_engine::Timer timer;
+  IomgrEventEngine* engine;
+  EventEngine::TaskHandle handle;
+
+  void Run() override {
+    GRPC_EVENT_ENGINE_TRACE("IomgrEventEngine:%p executing callback:%s", engine,
+                            HandleToString(handle).c_str());
+    {
+      grpc_core::MutexLock lock(&engine->mu_);
+      engine->known_handles_.erase(handle);
+    }
+    cb();
+    delete this;
+  }
+};
+
 IomgrEventEngine::IomgrEventEngine() {}
 
 IomgrEventEngine::~IomgrEventEngine() {
@@ -83,66 +82,39 @@ IomgrEventEngine::~IomgrEventEngine() {
 }
 
 bool IomgrEventEngine::Cancel(EventEngine::TaskHandle handle) {
-  grpc_core::ExecCtx ctx;
   grpc_core::MutexLock lock(&mu_);
   if (!known_handles_.contains(handle)) return false;
   auto* cd = reinterpret_cast<ClosureData*>(handle.keys[0]);
-  grpc_timer_cancel(&cd->timer);
+  bool r = timer_manager_.TimerCancel(&cd->timer);
   known_handles_.erase(handle);
-  return true;
+  if (r) delete cd;
+  return r;
 }
 
-EventEngine::TaskHandle IomgrEventEngine::RunAt(absl::Time when,
-                                                std::function<void()> closure) {
-  return RunAtInternal(when, std::move(closure));
+EventEngine::TaskHandle IomgrEventEngine::RunAfter(
+    Duration when, std::function<void()> closure) {
+  return RunAfterInternal(when, std::move(closure));
 }
 
-EventEngine::TaskHandle IomgrEventEngine::RunAt(absl::Time when,
-                                                EventEngine::Closure* closure) {
-  return RunAtInternal(when, closure);
+EventEngine::TaskHandle IomgrEventEngine::RunAfter(
+    Duration when, EventEngine::Closure* closure) {
+  return RunAfterInternal(when, [closure]() { closure->Run(); });
 }
 
 void IomgrEventEngine::Run(std::function<void()> closure) {
-  RunInternal(closure);
+  thread_pool_.Add(closure);
 }
 
 void IomgrEventEngine::Run(EventEngine::Closure* closure) {
-  RunInternal(closure);
+  thread_pool_.Add([closure]() { closure->Run(); });
 }
 
-EventEngine::TaskHandle IomgrEventEngine::RunAtInternal(
-    absl::Time when,
-    absl::variant<std::function<void()>, EventEngine::Closure*> cb) {
-  when = Clamp(when);
-  grpc_core::ExecCtx ctx;
+EventEngine::TaskHandle IomgrEventEngine::RunAfterInternal(
+    Duration when, std::function<void()> cb) {
+  auto when_ts = ToTimestamp(when);
   auto* cd = new ClosureData;
   cd->cb = std::move(cb);
   cd->engine = this;
-  GRPC_CLOSURE_INIT(
-      &cd->closure,
-      [](void* arg, grpc_error_handle error) {
-        auto* cd = static_cast<ClosureData*>(arg);
-        GRPC_EVENT_ENGINE_TRACE("IomgrEventEngine:%p executing callback:%s",
-                                cd->engine, HandleToString(cd->handle).c_str());
-        {
-          grpc_core::MutexLock lock(&cd->engine->mu_);
-          cd->engine->known_handles_.erase(cd->handle);
-        }
-        auto cleaner = absl::MakeCleanup([cd] { delete cd; });
-        if (error == GRPC_ERROR_CANCELLED) return;
-        grpc_core::Match(
-            cd->cb, [](EventEngine::Closure* cb) { cb->Run(); },
-            [](std::function<void()> fn) { fn(); });
-      },
-      cd, nullptr);
-  // kludge to deal with realtime/monotonic clock conversion
-  absl::Time absl_now = absl::Now();
-  grpc_core::Duration duration = grpc_core::Duration::Milliseconds(
-      absl::ToInt64Milliseconds(when - absl_now) + 1);
-  grpc_core::ExecCtx::Get()->InvalidateNow();
-  grpc_core::Timestamp when_internal = grpc_core::ExecCtx::Get()->Now() +
-                                       duration +
-                                       grpc_core::Duration::Milliseconds(1);
   EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
                                  aba_token_.fetch_add(1)};
   grpc_core::MutexLock lock(&mu_);
@@ -150,29 +122,10 @@ EventEngine::TaskHandle IomgrEventEngine::RunAtInternal(
   cd->handle = handle;
   GRPC_EVENT_ENGINE_TRACE("IomgrEventEngine:%p scheduling callback:%s", this,
                           HandleToString(handle).c_str());
-  grpc_timer_init(&cd->timer, when_internal, &cd->closure);
+  timer_manager_.TimerInit(&cd->timer, when_ts, cd);
   return handle;
 }
 
-void IomgrEventEngine::RunInternal(
-    absl::variant<std::function<void()>, EventEngine::Closure*> cb) {
-  auto* cd = new ClosureData;
-  cd->cb = std::move(cb);
-  cd->engine = this;
-  GRPC_CLOSURE_INIT(
-      &cd->closure,
-      [](void* arg, grpc_error_handle /*error*/) {
-        auto* cd = static_cast<ClosureData*>(arg);
-        auto cleaner = absl::MakeCleanup([cd] { delete cd; });
-        grpc_core::Match(
-            cd->cb, [](EventEngine::Closure* cb) { cb->Run(); },
-            [](std::function<void()> fn) { fn(); });
-      },
-      cd, nullptr);
-  // TODO(hork): have the EE spawn dedicated closure thread(s)
-  grpc_core::Executor::Run(&cd->closure, GRPC_ERROR_NONE);
-}
-
 std::unique_ptr<EventEngine::DNSResolver> IomgrEventEngine::GetDNSResolver(
     EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
   GPR_ASSERT(false && "unimplemented");
@@ -189,7 +142,7 @@ bool IomgrEventEngine::CancelConnect(EventEngine::ConnectionHandle /*handle*/) {
 EventEngine::ConnectionHandle IomgrEventEngine::Connect(
     OnConnectCallback /*on_connect*/, const ResolvedAddress& /*addr*/,
     const EndpointConfig& /*args*/, MemoryAllocator /*memory_allocator*/,
-    absl::Time /*deadline*/) {
+    Duration /*deadline*/) {
   GPR_ASSERT(false && "unimplemented");
 }
 

data/src/core/lib/event_engine/{iomgr_engine.h → iomgr_engine/iomgr_engine.h}

@@ -11,8 +11,8 @@
 // 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_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_H
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_IOMGR_ENGINE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_IOMGR_ENGINE_H
 #include <grpc/support/port_platform.h>
 
 #include <stdint.h>
@@ -25,8 +25,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/time/time.h"
-#include "absl/types/variant.h"
 
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
@@ -34,11 +32,16 @@
 #include <grpc/event_engine/slice_buffer.h>
 
 #include "src/core/lib/event_engine/handle_containers.h"
+#include "src/core/lib/event_engine/iomgr_engine/thread_pool.h"
+#include "src/core/lib/event_engine/iomgr_engine/timer_manager.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
+// An iomgr-based EventEngine implementation.
+// All methods require an ExecCtx to already exist on the thread's stack.
 class IomgrEventEngine final : public EventEngine {
  public:
   class IomgrEndpoint : public EventEngine::Endpoint {
@@ -63,13 +66,13 @@ class IomgrEventEngine final : public EventEngine {
     LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
                                     absl::string_view name,
                                     absl::string_view default_port,
-                                    absl::Time deadline) override;
+                                    Duration timeout) override;
     LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
                                absl::string_view name,
-                               absl::Time deadline) override;
+                               Duration timeout) override;
     LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
                                absl::string_view name,
-                               absl::Time deadline) override;
+                               Duration timeout) override;
     bool CancelLookup(LookupTaskHandle handle) override;
   };
 
@@ -87,7 +90,7 @@ class IomgrEventEngine final : public EventEngine {
                            const ResolvedAddress& addr,
                            const EndpointConfig& args,
                            MemoryAllocator memory_allocator,
-                           absl::Time deadline) override;
+                           Duration timeout) override;
 
   bool CancelConnect(ConnectionHandle handle) override;
   bool IsWorkerThread() override;
@@ -95,17 +98,18 @@ class IomgrEventEngine final : public EventEngine {
       const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
   void Run(std::function<void()> closure) override;
-  TaskHandle RunAt(absl::Time when, Closure* closure) override;
-  TaskHandle RunAt(absl::Time when, std::function<void()> closure) override;
+  TaskHandle RunAfter(Duration when, Closure* closure) override;
+  TaskHandle RunAfter(Duration when, std::function<void()> closure) override;
   bool Cancel(TaskHandle handle) override;
 
  private:
-  EventEngine::TaskHandle RunAtInternal(
-      absl::Time when,
-      absl::variant<std::function<void()>, EventEngine::Closure*> cb);
+  struct ClosureData;
+  EventEngine::TaskHandle RunAfterInternal(Duration when,
+                                           std::function<void()> cb);
+  grpc_core::Timestamp ToTimestamp(EventEngine::Duration when);
 
-  void RunInternal(
-      absl::variant<std::function<void()>, EventEngine::Closure*> cb);
+  iomgr_engine::TimerManager timer_manager_;
+  iomgr_engine::ThreadPool thread_pool_{2};
 
   grpc_core::Mutex mu_;
   TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
@@ -115,4 +119,4 @@ class IomgrEventEngine final : public EventEngine {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_IOMGR_ENGINE_H

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

@@ -0,0 +1,123 @@
+/*
+ *
+ * Copyright 2015 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/thread_pool.h"
+
+#include "src/core/lib/gprpp/thd.h"
+
+namespace grpc_event_engine {
+namespace iomgr_engine {
+
+ThreadPool::Thread::Thread(ThreadPool* pool)
+    : pool_(pool),
+      thd_(
+          "iomgr_eventengine_pool",
+          [](void* th) { static_cast<ThreadPool::Thread*>(th)->ThreadFunc(); },
+          this) {
+  thd_.Start();
+}
+ThreadPool::Thread::~Thread() { thd_.Join(); }
+
+void ThreadPool::Thread::ThreadFunc() {
+  pool_->ThreadFunc();
+  // Now that we have killed ourselves, we should reduce the thread count
+  grpc_core::MutexLock lock(&pool_->mu_);
+  pool_->nthreads_--;
+  // Move ourselves to dead list
+  pool_->dead_threads_.push_back(this);
+
+  if ((pool_->shutdown_) && (pool_->nthreads_ == 0)) {
+    pool_->shutdown_cv_.Signal();
+  }
+}
+
+void ThreadPool::ThreadFunc() {
+  for (;;) {
+    // Wait until work is available or we are shutting down.
+    grpc_core::ReleasableMutexLock lock(&mu_);
+    if (!shutdown_ && callbacks_.empty()) {
+      // If there are too many threads waiting, then quit this thread
+      if (threads_waiting_ >= reserve_threads_) {
+        break;
+      }
+      threads_waiting_++;
+      cv_.Wait(&mu_);
+      threads_waiting_--;
+    }
+    // Drain callbacks before considering shutdown to ensure all work
+    // gets completed.
+    if (!callbacks_.empty()) {
+      auto cb = callbacks_.front();
+      callbacks_.pop();
+      lock.Release();
+      cb();
+    } else if (shutdown_) {
+      break;
+    }
+  }
+}
+
+ThreadPool::ThreadPool(int reserve_threads)
+    : shutdown_(false),
+      reserve_threads_(reserve_threads),
+      nthreads_(0),
+      threads_waiting_(0) {
+  for (int i = 0; i < reserve_threads_; i++) {
+    grpc_core::MutexLock lock(&mu_);
+    nthreads_++;
+    new Thread(this);
+  }
+}
+
+void ThreadPool::ReapThreads(std::vector<Thread*>* tlist) {
+  for (auto* t : *tlist) delete t;
+  tlist->clear();
+}
+
+ThreadPool::~ThreadPool() {
+  grpc_core::MutexLock lock(&mu_);
+  shutdown_ = true;
+  cv_.SignalAll();
+  while (nthreads_ != 0) {
+    shutdown_cv_.Wait(&mu_);
+  }
+  ReapThreads(&dead_threads_);
+}
+
+void ThreadPool::Add(const std::function<void()>& callback) {
+  grpc_core::MutexLock lock(&mu_);
+  // Add works to the callbacks list
+  callbacks_.push(callback);
+  // Increase pool size or notify as needed
+  if (threads_waiting_ == 0) {
+    // Kick off a new thread
+    nthreads_++;
+    new Thread(this);
+  } else {
+    cv_.Signal();
+  }
+  // Also use this chance to harvest dead threads
+  if (!dead_threads_.empty()) {
+    ReapThreads(&dead_threads_);
+  }
+}
+
+}  // namespace iomgr_engine
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,70 @@
+/*
+ *
+ * Copyright 2015 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_THREAD_POOL_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_THREAD_POOL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+#include <queue>
+#include <vector>
+
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/thd.h"
+
+namespace grpc_event_engine {
+namespace iomgr_engine {
+
+class ThreadPool final {
+ public:
+  explicit ThreadPool(int reserve_threads);
+  ~ThreadPool();
+
+  void Add(const std::function<void()>& callback);
+
+ private:
+  class Thread {
+   public:
+    explicit Thread(ThreadPool* pool);
+    ~Thread();
+
+   private:
+    ThreadPool* pool_;
+    grpc_core::Thread thd_;
+    void ThreadFunc();
+  };
+
+  void ThreadFunc();
+  static void ReapThreads(std::vector<Thread*>* tlist);
+
+  grpc_core::Mutex mu_;
+  grpc_core::CondVar cv_;
+  grpc_core::CondVar shutdown_cv_;
+  bool shutdown_;
+  std::queue<std::function<void()>> callbacks_;
+  int reserve_threads_;
+  int nthreads_;
+  int threads_waiting_;
+  std::vector<Thread*> dead_threads_;
+};
+
+}  // namespace iomgr_engine
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_THREAD_POOL_H

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

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2015 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/time_averaged_stats.h"
+
+namespace grpc_event_engine {
+namespace iomgr_engine {
+
+TimeAveragedStats::TimeAveragedStats(double init_avg, double regress_weight,
+                                     double persistence_factor)
+    : init_avg_(init_avg),
+      regress_weight_(regress_weight),
+      persistence_factor_(persistence_factor) {}
+
+void TimeAveragedStats::AddSample(double value) {
+  batch_total_value_ += value;
+  ++batch_num_samples_;
+}
+
+double TimeAveragedStats::UpdateAverage() {
+  /* Start with the current batch: */
+  double weighted_sum = batch_total_value_;
+  double total_weight = batch_num_samples_;
+  if (regress_weight_ > 0) {
+    /* Add in the regression towards init_avg_: */
+    weighted_sum += regress_weight_ * init_avg_;
+    total_weight += regress_weight_;
+  }
+  if (persistence_factor_ > 0) {
+    /* Add in the persistence: */
+    const double prev_sample_weight =
+        persistence_factor_ * aggregate_total_weight_;
+    weighted_sum += prev_sample_weight * aggregate_weighted_avg_;
+    total_weight += prev_sample_weight;
+  }
+  aggregate_weighted_avg_ =
+      (total_weight > 0) ? (weighted_sum / total_weight) : init_avg_;
+  aggregate_total_weight_ = total_weight;
+  batch_num_samples_ = 0;
+  batch_total_value_ = 0;
+  return aggregate_weighted_avg_;
+}
+
+}  // namespace iomgr_engine
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,81 @@
+/*
+ *
+ * Copyright 2015 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_TIME_AVERAGED_STATS_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIME_AVERAGED_STATS_H
+
+namespace grpc_event_engine {
+namespace iomgr_engine {
+
+/* This tracks a time-decaying weighted average.  It works by collecting
+   batches of samples and then mixing their average into a time-decaying
+   weighted mean.  It is designed for batch operations where we do many adds
+   before updating the average. */
+
+class TimeAveragedStats {
+ public:
+  TimeAveragedStats(double init_avg, double regress_weight,
+                    double persistence_factor);
+
+  /* Add a sample to the current batch. */
+  void AddSample(double value);
+  /* Complete a batch and compute the new estimate of the average sample
+     value. */
+  double UpdateAverage();
+
+  double aggregate_weighted_avg() const { return aggregate_weighted_avg_; }
+  double aggregate_total_weight() const { return aggregate_total_weight_; }
+
+ private:
+  /* The initial average value.  This is the reported average until the first
+     grpc_time_averaged_stats_update_average call.  If a positive regress_weight
+     is used, we also regress towards this value on each update. */
+  const double init_avg_;
+  /* The sample weight of "init_avg" that is mixed in with each call to
+     grpc_time_averaged_stats_update_average.  If the calls to
+     grpc_time_averaged_stats_add_sample stop, this will cause the average to
+     regress back to the mean.  This should be non-negative.  Set it to 0 to
+     disable the bias.  A value of 1 has the effect of adding in 1 bonus sample
+     with value init_avg to each sample period. */
+  const double regress_weight_;
+  /* This determines the rate of decay of the time-averaging from one period
+     to the next by scaling the aggregate_total_weight of samples from prior
+     periods when combining with the latest period.  It should be in the range
+     [0,1].  A higher value adapts more slowly.  With a value of 0.5, if the
+     batches each have k samples, the samples_in_avg_ will grow to 2 k, so the
+     weighting of the time average will eventually be 1/3 new batch and 2/3
+     old average. */
+  const double persistence_factor_;
+
+  /* The total value of samples since the last UpdateAverage(). */
+  double batch_total_value_ = 0;
+  /* The number of samples since the last UpdateAverage(). */
+  double batch_num_samples_ = 0;
+  /* The time-decayed sum of batch_num_samples_ over previous batches.  This is
+     the "weight" of the old aggregate_weighted_avg_ when updating the
+     average. */
+  double aggregate_total_weight_ = 0;
+  /* A time-decayed average of the (batch_total_value_ / batch_num_samples_),
+     computed by decaying the samples_in_avg_ weight in the weighted average. */
+  double aggregate_weighted_avg_ = init_avg_;
+};
+
+}  // namespace iomgr_engine
+}  // namespace grpc_event_engine
+
+#endif /* GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIME_AVERAGED_STATS_H */