include/llvm/Support/ThreadPool.h

   1 //===-- llvm/Support/ThreadPool.h - A ThreadPool implementation -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines a crude C++11 based thread pool.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_SUPPORT_THREAD_POOL_H
  15 #define LLVM_SUPPORT_THREAD_POOL_H
  16
  17 #include "llvm/Support/thread.h"
  18
  19 #ifdef _MSC_VER
  20 // concrt.h depends on eh.h for __uncaught_exception declaration
  21 // even if we disable exceptions.
  22 #include <eh.h>
  23 #endif
  24
  25 #include <condition_variable>
  26 #include <functional>
  27 #include <future>
  28 #include <memory>
  29 #include <mutex>
  30 #include <queue>
  31 #include <utility>
  32
  33 namespace llvm {
  34
  35 /// A ThreadPool for asynchronous parallel execution on a defined number of
  36 /// threads.
  37 ///
  38 /// The pool keeps a vector of threads alive, waiting on a condition variable
  39 /// for some work to become available.
  40 class ThreadPool {
  41 public:
  42 #ifndef _MSC_VER
  43   using VoidTy = void;
  44   using TaskTy = std::function<void()>;
  45   using PackagedTaskTy = std::packaged_task<void()>;
  46 #else
  47   // MSVC 2013 has a bug and can't use std::packaged_task<void()>;
  48   // We force it to use bool(bool) instead.
  49   using VoidTy = bool;
  50   using TaskTy = std::function<bool(bool)>;
  51   using PackagedTaskTy = std::packaged_task<bool(bool)>;
  52 #endif
  53
  54   /// Construct a pool with the number of core available on the system (or
  55   /// whatever the value returned by std::thread::hardware_concurrency() is).
  56   ThreadPool();
  57
  58   /// Construct a pool of \p ThreadCount threads
  59   ThreadPool(unsigned ThreadCount);
  60
  61   /// Blocking destructor: the pool will wait for all the threads to complete.
  62   ~ThreadPool();
  63
  64   /// Asynchronous submission of a task to the pool. The returned future can be
  65   /// used to wait for the task to finish and is *non-blocking* on destruction.
  66   template <typename Function, typename... Args>
  67   inline std::shared_future<VoidTy> async(Function &&F, Args &&... ArgList) {
  68     auto Task =
  69         std::bind(std::forward<Function>(F), std::forward<Args...>(ArgList...));
  70 #ifndef _MSC_VER
  71     return asyncImpl(std::move(Task));
  72 #else
  73     return asyncImpl([Task] (VoidTy) -> VoidTy { Task(); return VoidTy(); });
  74 #endif
  75   }
  76
  77   /// Asynchronous submission of a task to the pool. The returned future can be
  78   /// used to wait for the task to finish and is *non-blocking* on destruction.
  79   template <typename Function>
  80   inline std::shared_future<VoidTy> async(Function &&F) {
  81 #ifndef _MSC_VER
  82     return asyncImpl(std::forward<Function>(F));
  83 #else
  84     return asyncImpl([F] (VoidTy) -> VoidTy { F(); return VoidTy(); });
  85 #endif
  86   }
  87
  88   /// Blocking wait for all the threads to complete and the queue to be empty.
  89   /// It is an error to try to add new tasks while blocking on this call.
  90   void wait();
  91
  92 private:
  93   /// Asynchronous submission of a task to the pool. The returned future can be
  94   /// used to wait for the task to finish and is *non-blocking* on destruction.
  95   std::shared_future<VoidTy> asyncImpl(TaskTy F);
  96
  97   /// Threads in flight
  98   std::vector<llvm::thread> Threads;
  99
 100   /// Tasks waiting for execution in the pool.
 101   std::queue<PackagedTaskTy> Tasks;
 102
 103   /// Locking and signaling for accessing the Tasks queue.
 104   std::mutex QueueLock;
 105   std::condition_variable QueueCondition;
 106
 107   /// Locking and signaling for job completion
 108   std::mutex CompletionLock;
 109   std::condition_variable CompletionCondition;
 110
 111   /// Keep track of the number of thread actually busy
 112   std::atomic<unsigned> ActiveThreads;
 113
 114 #if LLVM_ENABLE_THREADS // avoids warning for unused variable
 115   /// Signal for the destruction of the pool, asking thread to exit.
 116   bool EnableFlag;
 117 #endif
 118 };
 119 }
 120
 121 #endif // LLVM_SUPPORT_THREAD_POOL_H