grpc 1.47.0 → 1.49.0.pre1

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

@@ -1,206 +0,0 @@
-// Copyright 2022 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>
-
-#include "src/core/lib/event_engine/iomgr_engine.h"
-
-#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/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
-
-IomgrEventEngine::IomgrEventEngine() {}
-
-IomgrEventEngine::~IomgrEventEngine() {
-  grpc_core::MutexLock lock(&mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-    for (auto handle : known_handles_) {
-      gpr_log(GPR_ERROR,
-              "(event_engine) IomgrEventEngine:%p uncleared TaskHandle at "
-              "shutdown:%s",
-              this, HandleToString(handle).c_str());
-    }
-  }
-  GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
-}
-
-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);
-  known_handles_.erase(handle);
-  return true;
-}
-
-EventEngine::TaskHandle IomgrEventEngine::RunAt(absl::Time when,
-                                                std::function<void()> closure) {
-  return RunAtInternal(when, std::move(closure));
-}
-
-EventEngine::TaskHandle IomgrEventEngine::RunAt(absl::Time when,
-                                                EventEngine::Closure* closure) {
-  return RunAtInternal(when, closure);
-}
-
-void IomgrEventEngine::Run(std::function<void()> closure) {
-  RunInternal(closure);
-}
-
-void IomgrEventEngine::Run(EventEngine::Closure* closure) {
-  RunInternal(closure);
-}
-
-EventEngine::TaskHandle IomgrEventEngine::RunAtInternal(
-    absl::Time when,
-    absl::variant<std::function<void()>, EventEngine::Closure*> cb) {
-  when = Clamp(when);
-  grpc_core::ExecCtx ctx;
-  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_);
-  known_handles_.insert(handle);
-  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);
-  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");
-}
-
-bool IomgrEventEngine::IsWorkerThread() {
-  GPR_ASSERT(false && "unimplemented");
-}
-
-bool IomgrEventEngine::CancelConnect(EventEngine::ConnectionHandle /*handle*/) {
-  GPR_ASSERT(false && "unimplemented");
-}
-
-EventEngine::ConnectionHandle IomgrEventEngine::Connect(
-    OnConnectCallback /*on_connect*/, const ResolvedAddress& /*addr*/,
-    const EndpointConfig& /*args*/, MemoryAllocator /*memory_allocator*/,
-    absl::Time /*deadline*/) {
-  GPR_ASSERT(false && "unimplemented");
-}
-
-absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
-IomgrEventEngine::CreateListener(
-    Listener::AcceptCallback /*on_accept*/,
-    std::function<void(absl::Status)> /*on_shutdown*/,
-    const EndpointConfig& /*config*/,
-    std::unique_ptr<MemoryAllocatorFactory> /*memory_allocator_factory*/) {
-  GPR_ASSERT(false && "unimplemented");
-}
-
-}  // namespace experimental
-}  // namespace grpc_event_engine

data/src/core/lib/iomgr/error_internal.h

@@ -1,66 +0,0 @@
-/*
- *
- * Copyright 2016 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_IOMGR_ERROR_INTERNAL_H
-#define GRPC_CORE_LIB_IOMGR_ERROR_INTERNAL_H
-
-#include <grpc/support/port_platform.h>
-
-#include <inttypes.h>
-#include <stdbool.h>  // TODO(unknown): , do we need this?
-
-#include <grpc/support/sync.h>
-
-#include "src/core/lib/iomgr/error.h"
-
-#ifndef GRPC_ERROR_IS_ABSEIL_STATUS
-
-typedef struct grpc_linked_error grpc_linked_error;
-
-struct grpc_linked_error {
-  grpc_error_handle err;
-  uint8_t next;
-};
-
-// c core representation of an error. See error.h for high level description of
-// this object.
-struct grpc_error {
-  // All atomics in grpc_error must be stored in this nested struct. The rest of
-  // the object is memcpy-ed in bulk in copy_and_unref.
-  struct atomics {
-    gpr_refcount refs;
-    gpr_atm error_string;
-  } atomics;
-  // These arrays index into dynamic arena at the bottom of the struct.
-  // UINT8_MAX is used as a sentinel value.
-  uint8_t ints[GRPC_ERROR_INT_MAX];
-  uint8_t strs[GRPC_ERROR_STR_MAX];
-  uint8_t times[GRPC_ERROR_TIME_MAX];
-  // The child errors are stored in the arena, but are effectively a linked list
-  // structure, since they are contained within grpc_linked_error objects.
-  uint8_t first_err;
-  uint8_t last_err;
-  // The arena is dynamically reallocated with a grow factor of 1.5.
-  uint8_t arena_size;
-  uint8_t arena_capacity;
-  intptr_t arena[0];
-};
-
-#endif  // GRPC_ERROR_IS_ABSEIL_STATUS
-
-#endif /* GRPC_CORE_LIB_IOMGR_ERROR_INTERNAL_H */

data/src/core/lib/iomgr/executor/mpmcqueue.cc

@@ -1,182 +0,0 @@
-/*
- *
- * Copyright 2019 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/iomgr/executor/mpmcqueue.h"
-
-namespace grpc_core {
-
-DebugOnlyTraceFlag grpc_thread_pool_trace(false, "thread_pool");
-
-inline void* InfLenFIFOQueue::PopFront() {
-  // Caller should already check queue is not empty and has already held the
-  // mutex. This function will assume that there is at least one element in the
-  // queue (i.e. queue_head_->content is valid).
-  void* result = queue_head_->content;
-  count_.store(count_.load(std::memory_order_relaxed) - 1,
-               std::memory_order_relaxed);
-
-  // Updates Stats when trace flag turned on.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace)) {
-    gpr_timespec wait_time =
-        gpr_time_sub(gpr_now(GPR_CLOCK_MONOTONIC), queue_head_->insert_time);
-    stats_.num_completed++;
-    stats_.total_queue_time = gpr_time_add(stats_.total_queue_time, wait_time);
-    stats_.max_queue_time = gpr_time_max(
-        gpr_convert_clock_type(stats_.max_queue_time, GPR_TIMESPAN), wait_time);
-
-    if (count_.load(std::memory_order_relaxed) == 0) {
-      stats_.busy_queue_time =
-          gpr_time_add(stats_.busy_queue_time,
-                       gpr_time_sub(gpr_now(GPR_CLOCK_MONOTONIC), busy_time));
-    }
-
-    gpr_log(GPR_INFO,
-            "[InfLenFIFOQueue PopFront] num_completed:        %" PRIu64
-            " total_queue_time: %f max_queue_time:   %f busy_queue_time:   %f",
-            stats_.num_completed,
-            gpr_timespec_to_micros(stats_.total_queue_time),
-            gpr_timespec_to_micros(stats_.max_queue_time),
-            gpr_timespec_to_micros(stats_.busy_queue_time));
-  }
-
-  queue_head_ = queue_head_->next;
-  // Signal waiting thread
-  if (count_.load(std::memory_order_relaxed) > 0) {
-    TopWaiter()->cv.Signal();
-  }
-
-  return result;
-}
-
-InfLenFIFOQueue::Node* InfLenFIFOQueue::AllocateNodes(int num) {
-  num_nodes_ = num_nodes_ + num;
-  Node* new_chunk = new Node[num];
-  new_chunk[0].next = &new_chunk[1];
-  new_chunk[num - 1].prev = &new_chunk[num - 2];
-  for (int i = 1; i < num - 1; ++i) {
-    new_chunk[i].prev = &new_chunk[i - 1];
-    new_chunk[i].next = &new_chunk[i + 1];
-  }
-  return new_chunk;
-}
-
-InfLenFIFOQueue::InfLenFIFOQueue() {
-  delete_list_size_ = kDeleteListInitSize;
-  delete_list_ = new Node*[delete_list_size_];
-
-  Node* new_chunk = AllocateNodes(kQueueInitNumNodes);
-  delete_list_[delete_list_count_++] = new_chunk;
-  queue_head_ = queue_tail_ = new_chunk;
-  new_chunk[0].prev = &new_chunk[kQueueInitNumNodes - 1];
-  new_chunk[kQueueInitNumNodes - 1].next = &new_chunk[0];
-
-  waiters_.next = &waiters_;
-  waiters_.prev = &waiters_;
-}
-
-InfLenFIFOQueue::~InfLenFIFOQueue() {
-  GPR_ASSERT(count_.load(std::memory_order_relaxed) == 0);
-  for (size_t i = 0; i < delete_list_count_; ++i) {
-    delete[] delete_list_[i];
-  }
-  delete[] delete_list_;
-}
-
-void InfLenFIFOQueue::Put(void* elem) {
-  MutexLock l(&mu_);
-
-  int curr_count = count_.load(std::memory_order_relaxed);
-
-  if (queue_tail_ == queue_head_ && curr_count != 0) {
-    // List is full. Expands list to double size by inserting new chunk of nodes
-    Node* new_chunk = AllocateNodes(curr_count);
-    delete_list_[delete_list_count_++] = new_chunk;
-    // Expands delete list on full.
-    if (delete_list_count_ == delete_list_size_) {
-      delete_list_size_ = delete_list_size_ * 2;
-      delete_list_ = new Node*[delete_list_size_];
-    }
-    new_chunk[0].prev = queue_tail_->prev;
-    new_chunk[curr_count - 1].next = queue_head_;
-    queue_tail_->prev->next = new_chunk;
-    queue_head_->prev = &new_chunk[curr_count - 1];
-    queue_tail_ = new_chunk;
-  }
-  queue_tail_->content = static_cast<void*>(elem);
-
-  // Updates Stats info
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace)) {
-    stats_.num_started++;
-    gpr_log(GPR_INFO, "[InfLenFIFOQueue Put] num_started:        %" PRIu64,
-            stats_.num_started);
-    auto current_time = gpr_now(GPR_CLOCK_MONOTONIC);
-    if (curr_count == 0) {
-      busy_time = current_time;
-    }
-    queue_tail_->insert_time = current_time;
-  }
-
-  count_.store(curr_count + 1, std::memory_order_relaxed);
-  queue_tail_ = queue_tail_->next;
-
-  TopWaiter()->cv.Signal();
-}
-
-void* InfLenFIFOQueue::Get(gpr_timespec* wait_time) {
-  MutexLock l(&mu_);
-
-  if (count_.load(std::memory_order_relaxed) == 0) {
-    gpr_timespec start_time;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace) &&
-        wait_time != nullptr) {
-      start_time = gpr_now(GPR_CLOCK_MONOTONIC);
-    }
-
-    Waiter self;
-    PushWaiter(&self);
-    do {
-      self.cv.Wait(&mu_);
-    } while (count_.load(std::memory_order_relaxed) == 0);
-    RemoveWaiter(&self);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace) &&
-        wait_time != nullptr) {
-      *wait_time = gpr_time_sub(gpr_now(GPR_CLOCK_MONOTONIC), start_time);
-    }
-  }
-  GPR_DEBUG_ASSERT(count_.load(std::memory_order_relaxed) > 0);
-  return PopFront();
-}
-
-void InfLenFIFOQueue::PushWaiter(Waiter* waiter) {
-  waiter->next = waiters_.next;
-  waiter->prev = &waiters_;
-  waiter->next->prev = waiter;
-  waiter->prev->next = waiter;
-}
-
-void InfLenFIFOQueue::RemoveWaiter(Waiter* waiter) {
-  GPR_DEBUG_ASSERT(waiter != &waiters_);
-  waiter->next->prev = waiter->prev;
-  waiter->prev->next = waiter->next;
-}
-
-InfLenFIFOQueue::Waiter* InfLenFIFOQueue::TopWaiter() { return waiters_.next; }
-
-}  // namespace grpc_core

data/src/core/lib/iomgr/executor/mpmcqueue.h

@@ -1,171 +0,0 @@
-/*
- *
- * Copyright 2019 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_IOMGR_EXECUTOR_MPMCQUEUE_H
-#define GRPC_CORE_LIB_IOMGR_EXECUTOR_MPMCQUEUE_H
-
-#include <grpc/support/port_platform.h>
-
-#include <atomic>
-
-#include "src/core/lib/debug/stats.h"
-#include "src/core/lib/gprpp/sync.h"
-
-namespace grpc_core {
-
-extern DebugOnlyTraceFlag grpc_thread_pool_trace;
-
-// Abstract base class of a Multiple-Producer-Multiple-Consumer(MPMC) queue
-// interface
-class MPMCQueueInterface {
- public:
-  virtual ~MPMCQueueInterface() {}
-
-  // Puts elem into queue immediately at the end of queue.
-  // This might cause to block on full queue depending on implementation.
-  virtual void Put(void* elem) = 0;
-
-  // Removes the oldest element from the queue and return it.
-  // This might cause to block on empty queue depending on implementation.
-  // Optional argument for collecting stats purpose.
-  virtual void* Get(gpr_timespec* wait_time) = 0;
-
-  // Returns number of elements in the queue currently
-  virtual int count() const = 0;
-};
-
-class InfLenFIFOQueue : public MPMCQueueInterface {
- public:
-  // Creates a new MPMC Queue. The queue created will have infinite length.
-  InfLenFIFOQueue();
-
-  // Releases all resources held by the queue. The queue must be empty, and no
-  // one waits on conditional variables.
-  ~InfLenFIFOQueue() override;
-
-  // Puts elem into queue immediately at the end of queue. Since the queue has
-  // infinite length, this routine will never block and should never fail.
-  void Put(void* elem) override;
-
-  // Removes the oldest element from the queue and returns it.
-  // This routine will cause the thread to block if queue is currently empty.
-  // Argument wait_time should be passed in when trace flag turning on (for
-  // collecting stats info purpose.)
-  void* Get(gpr_timespec* wait_time) override;
-
-  // Returns number of elements in queue currently.
-  // There might be concurrently add/remove on queue, so count might change
-  // quickly.
-  int count() const override { return count_.load(std::memory_order_relaxed); }
-
-  struct Node {
-    Node* next = nullptr;  // Linking
-    Node* prev = nullptr;
-    void* content = nullptr;   // Points to actual element
-    gpr_timespec insert_time;  // Time for stats
-  };
-
-  // For test purpose only. Returns number of nodes allocated in queue.
-  // Any allocated node will be alive until the destruction of the queue.
-  int num_nodes() const { return num_nodes_; }
-
-  // For test purpose only. Returns the initial number of nodes in queue.
-  int init_num_nodes() const { return kQueueInitNumNodes; }
-
- private:
-  // For Internal Use Only.
-  // Removes the oldest element from the queue and returns it. This routine
-  // will NOT check whether queue is empty, and it will NOT acquire mutex.
-  // Caller MUST check that queue is not empty and must acquire mutex before
-  // callling.
-  void* PopFront();
-
-  // Stats of queue. This will only be collect when debug trace mode is on.
-  // All printed stats info will have time measurement in microsecond.
-  struct Stats {
-    uint64_t num_started;    // Number of elements have been added to queue
-    uint64_t num_completed;  // Number of elements have been removed from
-                             // the queue
-    gpr_timespec total_queue_time;  // Total waiting time that all the
-                                    // removed elements have spent in queue
-    gpr_timespec max_queue_time;    // Max waiting time among all removed
-                                    // elements
-    gpr_timespec busy_queue_time;   // Accumulated amount of time that queue
-                                    // was not empty
-
-    Stats() {
-      num_started = 0;
-      num_completed = 0;
-      total_queue_time = gpr_time_0(GPR_TIMESPAN);
-      max_queue_time = gpr_time_0(GPR_TIMESPAN);
-      busy_queue_time = gpr_time_0(GPR_TIMESPAN);
-    }
-  };
-
-  // Node for waiting thread queue. Stands for one waiting thread, should have
-  // exact one thread waiting on its CondVar.
-  // Using a doubly linked list for waiting thread queue to wake up waiting
-  // threads in LIFO order to reduce cache misses.
-  struct Waiter {
-    CondVar cv;
-    Waiter* next;
-    Waiter* prev;
-  };
-
-  // Pushs waiter to the front of queue, require caller held mutex
-  void PushWaiter(Waiter* waiter);
-
-  // Removes waiter from queue, require caller held mutex
-  void RemoveWaiter(Waiter* waiter);
-
-  // Returns pointer to the waiter that should be waken up next, should be the
-  // last added waiter.
-  Waiter* TopWaiter();
-
-  Mutex mu_;        // Protecting lock
-  Waiter waiters_;  // Head of waiting thread queue
-
-  // Initial size for delete list
-  static const int kDeleteListInitSize = 1024;
-  // Initial number of nodes allocated
-  static const int kQueueInitNumNodes = 1024;
-
-  Node** delete_list_ = nullptr;  // Keeps track of all allocated array entries
-                                  // for deleting on destruction
-  size_t delete_list_count_ = 0;  // Number of entries in list
-  size_t delete_list_size_ = 0;   // Size of the list. List will be expanded to
-                                  // double size on full
-
-  Node* queue_head_ = nullptr;  // Head of the queue, remove position
-  Node* queue_tail_ = nullptr;  // End of queue, insert position
-  std::atomic<int> count_{0};   // Number of elements in queue
-  int num_nodes_ = 0;           // Number of nodes allocated
-
-  Stats stats_;            // Stats info
-  gpr_timespec busy_time;  // Start time of busy queue
-
-  // Internal Helper.
-  // Allocates an array of nodes of size "num", links all nodes together except
-  // the first node's prev and last node's next. They should be set by caller
-  // manually afterward.
-  Node* AllocateNodes(int num);
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_IOMGR_EXECUTOR_MPMCQUEUE_H */