grpc 1.46.3 → 1.53.1

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 */

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

@@ -1,136 +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/threadpool.h"
-
-namespace grpc_core {
-
-void ThreadPoolWorker::Run() {
-  while (true) {
-    void* elem;
-
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace)) {
-      // Updates stats and print
-      gpr_timespec wait_time = gpr_time_0(GPR_TIMESPAN);
-      elem = queue_->Get(&wait_time);
-      stats_.sleep_time = gpr_time_add(stats_.sleep_time, wait_time);
-      gpr_log(GPR_INFO,
-              "ThreadPool Worker [%s %d] Stats:  sleep_time          %f",
-              thd_name_, index_, gpr_timespec_to_micros(stats_.sleep_time));
-    } else {
-      elem = queue_->Get(nullptr);
-    }
-    if (elem == nullptr) {
-      break;
-    }
-    // Runs closure
-    auto* closure = static_cast<grpc_completion_queue_functor*>(elem);
-    closure->functor_run(closure, closure->internal_success);
-  }
-}
-
-void ThreadPool::SharedThreadPoolConstructor() {
-  // All worker threads in thread pool must be joinable.
-  thread_options_.set_joinable(true);
-
-  // Create at least 1 worker thread.
-  if (num_threads_ <= 0) num_threads_ = 1;
-
-  queue_ = new InfLenFIFOQueue();
-  threads_ = static_cast<ThreadPoolWorker**>(
-      gpr_zalloc(num_threads_ * sizeof(ThreadPoolWorker*)));
-  for (int i = 0; i < num_threads_; ++i) {
-    threads_[i] = new ThreadPoolWorker(thd_name_, queue_, thread_options_, i);
-    threads_[i]->Start();
-  }
-}
-
-size_t ThreadPool::DefaultStackSize() {
-#if defined(__ANDROID__) || defined(__APPLE__)
-  return 1952 * 1024;
-#else
-  return 64 * 1024;
-#endif
-}
-
-void ThreadPool::AssertHasNotBeenShutDown() {
-  // For debug checking purpose, using RELAXED order is sufficient.
-  GPR_DEBUG_ASSERT(!shut_down_.load(std::memory_order_relaxed));
-}
-
-ThreadPool::ThreadPool(int num_threads) : num_threads_(num_threads) {
-  thd_name_ = "ThreadPoolWorker";
-  thread_options_ = Thread::Options();
-  thread_options_.set_stack_size(DefaultStackSize());
-  SharedThreadPoolConstructor();
-}
-
-ThreadPool::ThreadPool(int num_threads, const char* thd_name)
-    : num_threads_(num_threads), thd_name_(thd_name) {
-  thread_options_ = Thread::Options();
-  thread_options_.set_stack_size(DefaultStackSize());
-  SharedThreadPoolConstructor();
-}
-
-ThreadPool::ThreadPool(int num_threads, const char* thd_name,
-                       const Thread::Options& thread_options)
-    : num_threads_(num_threads),
-      thd_name_(thd_name),
-      thread_options_(thread_options) {
-  if (thread_options_.stack_size() == 0) {
-    thread_options_.set_stack_size(DefaultStackSize());
-  }
-  SharedThreadPoolConstructor();
-}
-
-ThreadPool::~ThreadPool() {
-  // For debug checking purpose, using RELAXED order is sufficient.
-  shut_down_.store(true, std::memory_order_relaxed);
-
-  for (int i = 0; i < num_threads_; ++i) {
-    queue_->Put(nullptr);
-  }
-
-  for (int i = 0; i < num_threads_; ++i) {
-    threads_[i]->Join();
-  }
-
-  for (int i = 0; i < num_threads_; ++i) {
-    delete threads_[i];
-  }
-  gpr_free(threads_);
-  delete queue_;
-}
-
-void ThreadPool::Add(grpc_completion_queue_functor* closure) {
-  AssertHasNotBeenShutDown();
-  queue_->Put(static_cast<void*>(closure));
-}
-
-int ThreadPool::num_pending_closures() const { return queue_->count(); }
-
-int ThreadPool::pool_capacity() const { return num_threads_; }
-
-const Thread::Options& ThreadPool::thread_options() const {
-  return thread_options_;
-}
-
-const char* ThreadPool::thread_name() const { return thd_name_; }
-}  // namespace grpc_core

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

@@ -1,150 +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_THREADPOOL_H
-#define GRPC_CORE_LIB_IOMGR_EXECUTOR_THREADPOOL_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/grpc.h>
-
-#include "src/core/lib/gprpp/thd.h"
-#include "src/core/lib/iomgr/executor/mpmcqueue.h"
-
-namespace grpc_core {
-
-// A base abstract base class for threadpool.
-// Threadpool is an executor that maintains a pool of threads sitting around
-// and waiting for closures. A threadpool also maintains a queue of pending
-// closures, when closures appearing in the queue, the threads in pool will
-// pull them out and execute them.
-class ThreadPoolInterface {
- public:
-  // Waits for all pending closures to complete, then shuts down thread pool.
-  virtual ~ThreadPoolInterface() {}
-
-  // Schedules a given closure for execution later.
-  // Depending on specific subclass implementation, this routine might cause
-  // current thread to be blocked (in case of unable to schedule).
-  // Closure should contain a function pointer and arguments it will take, more
-  // details for closure struct at /grpc/include/grpc/impl/codegen/grpc_types.h
-  virtual void Add(grpc_completion_queue_functor* closure) = 0;
-
-  // Returns the current number of pending closures
-  virtual int num_pending_closures() const = 0;
-
-  // Returns the capacity of pool (number of worker threads in pool)
-  virtual int pool_capacity() const = 0;
-
-  // Thread option accessor
-  virtual const Thread::Options& thread_options() const = 0;
-
-  // Returns the thread name for threads in this ThreadPool.
-  virtual const char* thread_name() const = 0;
-};
-
-// Worker thread for threadpool. Executes closures in the queue, until getting a
-// NULL closure.
-class ThreadPoolWorker {
- public:
-  ThreadPoolWorker(const char* thd_name, MPMCQueueInterface* queue,
-                   Thread::Options& options, int index)
-      : queue_(queue), thd_name_(thd_name), index_(index) {
-    thd_ = Thread(
-        thd_name, [](void* th) { static_cast<ThreadPoolWorker*>(th)->Run(); },
-        this, nullptr, options);
-  }
-
-  ~ThreadPoolWorker() {}
-
-  void Start() { thd_.Start(); }
-  void Join() { thd_.Join(); }
-
- private:
-  // struct for tracking stats of thread
-  struct Stats {
-    gpr_timespec sleep_time;
-    Stats() { sleep_time = gpr_time_0(GPR_TIMESPAN); }
-  };
-
-  void Run();  // Pulls closures from queue and executes them
-
-  MPMCQueueInterface* queue_;  // Queue in thread pool to pull closures from
-  Thread thd_;                 // Thread wrapped in
-  Stats stats_;                // Stats to be collected in run time
-  const char* thd_name_;       // Name of thread
-  int index_;                  // Index in thread pool
-};
-
-// A fixed size thread pool implementation of abstract thread pool interface.
-// In this implementation, the number of threads in pool is fixed, but the
-// capacity of closure queue is unlimited.
-class ThreadPool : public ThreadPoolInterface {
- public:
-  // Creates a thread pool with size of "num_threads", with default thread name
-  // "ThreadPoolWorker" and all thread options set to default. If the given size
-  // is 0 or less, there will be 1 worker thread created inside pool.
-  explicit ThreadPool(int num_threads);
-
-  // Same as ThreadPool(int num_threads) constructor, except
-  // that it also sets "thd_name" as the name of all threads in the thread pool.
-  ThreadPool(int num_threads, const char* thd_name);
-
-  // Same as ThreadPool(const char *thd_name, int num_threads) constructor,
-  // except that is also set thread_options for threads.
-  // Notes for stack size:
-  // If the stack size field of the passed in Thread::Options is set to default
-  // value 0, default ThreadPool stack size will be used. The current default
-  // stack size of this implementation is 1952K for mobile platform and 64K for
-  // all others.
-  ThreadPool(int num_threads, const char* thd_name,
-             const Thread::Options& thread_options);
-
-  // Waits for all pending closures to complete, then shuts down thread pool.
-  ~ThreadPool() override;
-
-  // Adds given closure into pending queue immediately. Since closure queue has
-  // infinite length, this routine will not block.
-  void Add(grpc_completion_queue_functor* closure) override;
-
-  int num_pending_closures() const override;
-  int pool_capacity() const override;
-  const Thread::Options& thread_options() const override;
-  const char* thread_name() const override;
-
- private:
-  int num_threads_ = 0;
-  const char* thd_name_ = nullptr;
-  Thread::Options thread_options_;
-  ThreadPoolWorker** threads_ = nullptr;  // Array of worker threads
-  MPMCQueueInterface* queue_ = nullptr;   // Closure queue
-
-  std::atomic<bool> shut_down_{
-      false};  // Destructor has been called if set to true
-
-  void SharedThreadPoolConstructor();
-  // For ThreadPool, default stack size for mobile platform is 1952K. for other
-  // platforms is 64K.
-  size_t DefaultStackSize();
-  // Internal Use Only for debug checking.
-  void AssertHasNotBeenShutDown();
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_IOMGR_EXECUTOR_THREADPOOL_H */