grpc 1.22.0 → 1.23.0

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

@@ -0,0 +1,178 @@
+/*
+ *
+ * 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 "src/core/lib/debug/stats.h"
+#include "src/core/lib/gprpp/abstract.h"
+#include "src/core/lib/gprpp/atomic.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) GRPC_ABSTRACT;
+
+  // 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 = nullptr) GRPC_ABSTRACT;
+
+  // Returns number of elements in the queue currently
+  virtual int count() const GRPC_ABSTRACT;
+
+  GRPC_ABSTRACT_BASE_CLASS
+};
+
+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();
+
+  // 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);
+
+  // 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 = nullptr);
+
+  // Returns number of elements in queue currently.
+  // There might be concurrently add/remove on queue, so count might change
+  // quickly.
+  int count() const { return count_.Load(MemoryOrder::RELAXED); }
+
+  struct Node {
+    Node* next;  // Linking
+    Node* prev;
+    void* content;             // Points to actual element
+    gpr_timespec insert_time;  // Time for stats
+
+    Node() {
+      next = prev = nullptr;
+      content = nullptr;
+    }
+  };
+
+  // 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
+  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

@@ -0,0 +1,138 @@
+/*
+ *
+ * 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_experimental_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_, this, 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(MemoryOrder::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, MemoryOrder::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_experimental_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

@@ -0,0 +1,153 @@
+/*
+ *
+ * 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_experimental_completion_queue_functor* closure)
+      GRPC_ABSTRACT;
+
+  // Returns the current number of pending closures
+  virtual int num_pending_closures() const GRPC_ABSTRACT;
+
+  // Returns the capacity of pool (number of worker threads in pool)
+  virtual int pool_capacity() const GRPC_ABSTRACT;
+
+  // Thread option accessor
+  virtual const Thread::Options& thread_options() const GRPC_ABSTRACT;
+
+  // Returns the thread name for threads in this ThreadPool.
+  virtual const char* thread_name() const GRPC_ABSTRACT;
+
+  GRPC_ABSTRACT_BASE_CLASS
+};
+
+// Worker thread for threadpool. Executes closures in the queue, until getting a
+// NULL closure.
+class ThreadPoolWorker {
+ public:
+  ThreadPoolWorker(const char* thd_name, ThreadPoolInterface* pool,
+                   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.
+  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_experimental_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
+
+  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 */