grpc 1.47.0 → 1.49.0.pre1

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

data/src/core/lib/iomgr/time_averaged_stats.cc

@@ -1,64 +0,0 @@
-/*
- *
- * 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/iomgr/time_averaged_stats.h"
-
-void grpc_time_averaged_stats_init(grpc_time_averaged_stats* stats,
-                                   double init_avg, double regress_weight,
-                                   double persistence_factor) {
-  stats->init_avg = init_avg;
-  stats->regress_weight = regress_weight;
-  stats->persistence_factor = persistence_factor;
-  stats->batch_total_value = 0;
-  stats->batch_num_samples = 0;
-  stats->aggregate_total_weight = 0;
-  stats->aggregate_weighted_avg = init_avg;
-}
-
-void grpc_time_averaged_stats_add_sample(grpc_time_averaged_stats* stats,
-                                         double value) {
-  stats->batch_total_value += value;
-  ++stats->batch_num_samples;
-}
-
-double grpc_time_averaged_stats_update_average(
-    grpc_time_averaged_stats* stats) {
-  /* Start with the current batch: */
-  double weighted_sum = stats->batch_total_value;
-  double total_weight = stats->batch_num_samples;
-  if (stats->regress_weight > 0) {
-    /* Add in the regression towards init_avg_: */
-    weighted_sum += stats->regress_weight * stats->init_avg;
-    total_weight += stats->regress_weight;
-  }
-  if (stats->persistence_factor > 0) {
-    /* Add in the persistence: */
-    const double prev_sample_weight =
-        stats->persistence_factor * stats->aggregate_total_weight;
-    weighted_sum += prev_sample_weight * stats->aggregate_weighted_avg;
-    total_weight += prev_sample_weight;
-  }
-  stats->aggregate_weighted_avg =
-      (total_weight > 0) ? (weighted_sum / total_weight) : stats->init_avg;
-  stats->aggregate_total_weight = total_weight;
-  stats->batch_num_samples = 0;
-  stats->batch_total_value = 0;
-  return stats->aggregate_weighted_avg;
-}