FM / core

/usr/local/lib64/python3.6/site-packages/torch/include/c10/core/

/usr/local/lib64/python3.6/site-packages/torch/include/c10/core

Name	Size	Mode	Actions
impl/	-	0755	rm
Allocator.h	8725	0644	edit dl rm
AutogradState.h	994	0644	edit dl rm
Backend.h	8487	0644	edit dl rm
CompileTimeFunctionPointer.h	1677	0644	edit dl rm
CopyBytes.h	1229	0644	edit dl rm
CPUAllocator.h	2267	0644	edit dl rm
DefaultDtype.h	394	0644	edit dl rm
DefaultTensorOptions.h	1032	0644	edit dl rm
Device.h	5396	0644	edit dl rm
DeviceGuard.h	7555	0644	edit dl rm
DeviceType.h	2994	0644	edit dl rm
DispatchKey.h	18069	0644	edit dl rm
DispatchKeySet.h	12951	0644	edit dl rm
Event.h	4169	0644	edit dl rm
GeneratorImpl.h	3713	0644	edit dl rm
GradMode.h	1261	0644	edit dl rm
InferenceMode.h	3471	0644	edit dl rm
Layout.h	1225	0644	edit dl rm
MemoryFormat.h	8571	0644	edit dl rm
OptionalRef.h	521	0644	edit dl rm
QEngine.h	861	0644	edit dl rm
QScheme.h	1562	0644	edit dl rm
Scalar.h	6019	0644	edit dl rm
ScalarType.h	17073	0644	edit dl rm
ScalarTypeToTypeMeta.h	1365	0644	edit dl rm
Storage.h	4369	0644	edit dl rm
StorageImpl.h	5610	0644	edit dl rm
Stream.h	7373	0644	edit dl rm
StreamGuard.h	6315	0644	edit dl rm
TensorImpl.h	96152	0644	edit dl rm
TensorOptions.h	27593	0644	edit dl rm
thread_pool.h	2992	0644	edit dl rm
UndefinedTensorImpl.h	911	0644	edit dl rm
WrapDimMinimal.h	805	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/torch/include/c10/core/thread_pool.h (2992B)

#pragma once

#include <condition_variable>
#include <functional>
#include <mutex>
#include <queue>
#include <thread>
#include <utility>

#include <c10/util/Optional.h>
#include <c10/util/intrusive_ptr.h>
#include <c10/util/numa.h>
#include <c10/util/thread_name.h>

namespace c10 {

// TODO: move this to C10 and make it C10_API
class C10_API TaskThreadPoolBase {
 public:
  virtual void run(std::function<void()> func) = 0;

virtual size_t size() const = 0;

/**
   * The number of available (i.e. idle) threads in this thread pool.
   */
  virtual size_t numAvailable() const = 0;

/**
   * Check if the current thread is from the thread pool.
   */
  virtual bool inThreadPool() const = 0;

virtual ~TaskThreadPoolBase() noexcept {}

static size_t defaultNumThreads() {
    auto num_threads = std::thread::hardware_concurrency();
#if defined(_M_X64) || defined(__x86_64__)
    num_threads /= 2;
#endif
    return num_threads;
  }
};

class C10_API ThreadPool : public c10::TaskThreadPoolBase {
 protected:
  struct task_element_t {
    bool run_with_id;
    const std::function<void()> no_id;
    const std::function<void(std::size_t)> with_id;

explicit task_element_t(std::function<void()> f)
        : run_with_id(false), no_id(std::move(f)), with_id(nullptr) {}
    explicit task_element_t(std::function<void(std::size_t)> f)
        : run_with_id(true), no_id(nullptr), with_id(std::move(f)) {}
  };

std::queue<task_element_t> tasks_;
  std::vector<std::thread> threads_;
  mutable std::mutex mutex_;
  std::condition_variable condition_;
  std::condition_variable completed_;
  std::atomic_bool running_;
  bool complete_;
  std::size_t available_;
  std::size_t total_;
  int numa_node_id_;

public:
  ThreadPool() = delete;

explicit ThreadPool(
      int pool_size,
      int numa_node_id = -1,
      std::function<void()> init_thread = nullptr);

~ThreadPool();

size_t size() const override;

size_t numAvailable() const override;

bool inThreadPool() const override;

void run(std::function<void()> func) override;

template <typename Task>
  void runTaskWithID(Task task) {
    std::unique_lock<std::mutex> lock(mutex_);

// Set task and signal condition variable so that a worker thread will
    // wake up and use the task.
    tasks_.emplace(static_cast<std::function<void(std::size_t)>>(task));
    complete_ = false;
    condition_.notify_one();
  }

/// @brief Wait for queue to be empty
  void waitWorkComplete();

private:
  // @brief Entry point for pool threads.
  void main_loop(std::size_t index);
};

class C10_API TaskThreadPool : public c10::ThreadPool {
 public:
  explicit TaskThreadPool(std::size_t pool_size, int numa_node_id = -1)
      : ThreadPool(pool_size, numa_node_id, [numa_node_id]() {
          setThreadName("CaffeTaskThread");
          NUMABind(numa_node_id);
        }) {}
};

C10_DECLARE_SHARED_REGISTRY(
    ThreadPoolRegistry,
    TaskThreadPoolBase,
    int,
    int,
    bool);

} // namespace c10

cmd: