Support: Remove MSVC 2013 workarounds in ThreadPool class.

[pcc]

Summary

I have confirmed that these are no longer needed with MSVC 2015.

[davide]

LGTM. Had the same change locally but never upstreamed.

[davide]

Ideally we should also remove the unused std::shared_future<void> returned as after years there's not a single consumer and that just complicates the API for no reason whatsoever.

llvm/trunk/include/llvm/Support/ThreadPool.h

 
 /// A ThreadPool for asynchronous parallel execution on a defined number of
 /// threads.
 ///
 /// The pool keeps a vector of threads alive, waiting on a condition variable
 /// for some work to become available.
 class ThreadPool {
 public:
-#ifndef _MSC_VER
-  using VoidTy = void;
   using TaskTy = std::function<void()>;
   using PackagedTaskTy = std::packaged_task<void()>;
-#else
-  // MSVC 2013 has a bug and can't use std::packaged_task<void()>;
-  // We force it to use bool(bool) instead.
-  using VoidTy = bool;
-  using TaskTy = std::function<bool(bool)>;
-  using PackagedTaskTy = std::packaged_task<bool(bool)>;
-#endif
 
   /// Construct a pool with the number of core available on the system (or
   /// whatever the value returned by std::thread::hardware_concurrency() is).
   ThreadPool();
 
   /// Construct a pool of \p ThreadCount threads
   ThreadPool(unsigned ThreadCount);
 
   /// Blocking destructor: the pool will wait for all the threads to complete.
   ~ThreadPool();
 
   /// Asynchronous submission of a task to the pool. The returned future can be
   /// used to wait for the task to finish and is *non-blocking* on destruction.
   template <typename Function, typename... Args>
-  inline std::shared_future<VoidTy> async(Function &&F, Args &&... ArgList) {
+  inline std::shared_future<void> async(Function &&F, Args &&... ArgList) {
     auto Task =
         std::bind(std::forward<Function>(F), std::forward<Args>(ArgList)...);
-#ifndef _MSC_VER
     return asyncImpl(std::move(Task));
-#else
-    // This lambda has to be marked mutable because MSVC 2013's std::bind call
-    // operator isn't const qualified.
-    return asyncImpl([Task](VoidTy) mutable -> VoidTy {
-      Task();
-      return VoidTy();
-    });
-#endif
   }
 
   /// Asynchronous submission of a task to the pool. The returned future can be
   /// used to wait for the task to finish and is *non-blocking* on destruction.
   template <typename Function>
-  inline std::shared_future<VoidTy> async(Function &&F) {
-#ifndef _MSC_VER
+  inline std::shared_future<void> async(Function &&F) {
     return asyncImpl(std::forward<Function>(F));
-#else
-    return asyncImpl([F] (VoidTy) -> VoidTy { F(); return VoidTy(); });
-#endif
   }
 
   /// Blocking wait for all the threads to complete and the queue to be empty.
   /// It is an error to try to add new tasks while blocking on this call.
   void wait();
 
 private:
   /// Asynchronous submission of a task to the pool. The returned future can be
   /// used to wait for the task to finish and is *non-blocking* on destruction.
-  std::shared_future<VoidTy> asyncImpl(TaskTy F);
+  std::shared_future<void> asyncImpl(TaskTy F);
 
   /// Threads in flight
   std::vector<llvm::thread> Threads;
 
   /// Tasks waiting for execution in the pool.
   std::queue<PackagedTaskTy> Tasks;
 
   /// Locking and signaling for accessing the Tasks queue.

llvm/trunk/lib/Support/ThreadPool.cpp

Threads.emplace_back([&] {
           {
             ++ActiveThreads;
             std::unique_lock<std::mutex> LockGuard(CompletionLock);
           }
           Task = std::move(Tasks.front());
           Tasks.pop();
         }
         // Run the task we just grabbed
-#ifndef _MSC_VER
         Task();
-#else
-        Task(/* unused */ false);
-#endif
 
         {
           // Adjust `ActiveThreads`, in case someone waits on ThreadPool::wait()
           std::unique_lock<std::mutex> LockGuard(CompletionLock);
           --ActiveThreads;
         }
 
         // Notify task completion, in case someone waits on ThreadPool::wait()
         CompletionCondition.notify_all();
       }
     });
   }
 }
 
 void ThreadPool::wait() {
   // Wait for all threads to complete and the queue to be empty
   std::unique_lock<std::mutex> LockGuard(CompletionLock);
   // The order of the checks for ActiveThreads and Tasks.empty() matters because
   // any active threads might be modifying the Tasks queue, and this would be a
   // race.
   CompletionCondition.wait(LockGuard,
                            [&] { return !ActiveThreads && Tasks.empty(); });
 }
 
-std::shared_future<ThreadPool::VoidTy> ThreadPool::asyncImpl(TaskTy Task) {
+std::shared_future<void> ThreadPool::asyncImpl(TaskTy Task) {
   /// Wrap the Task in a packaged_task to return a future object.
   PackagedTaskTy PackagedTask(std::move(Task));
   auto Future = PackagedTask.get_future();
   {
     // Lock the queue and push the new task
     std::unique_lock<std::mutex> LockGuard(QueueLock);
 
     // Don't allow enqueueing after disabling the pool
ThreadPool::ThreadPool(unsigned ThreadCount)
   }
 }
 
 void ThreadPool::wait() {
   // Sequential implementation running the tasks
   while (!Tasks.empty()) {
     auto Task = std::move(Tasks.front());
     Tasks.pop();
-#ifndef _MSC_VER
-        Task();
-#else
-        Task(/* unused */ false);
-#endif
   }
 }
 
-std::shared_future<ThreadPool::VoidTy> ThreadPool::asyncImpl(TaskTy Task) {
-#ifndef _MSC_VER
+std::shared_future<void> ThreadPool::asyncImpl(TaskTy Task) {
   // Get a Future with launch::deferred execution using std::async
   auto Future = std::async(std::launch::deferred, std::move(Task)).share();
   // Wrap the future so that both ThreadPool::wait() can operate and the
   // returned future can be sync'ed on.
   PackagedTaskTy PackagedTask([Future]() { Future.get(); });
-#else
-  auto Future = std::async(std::launch::deferred, std::move(Task), false).share();
-  PackagedTaskTy PackagedTask([Future](bool) -> bool { Future.get(); return false; });
-#endif
   Tasks.push(std::move(PackagedTask));
   return Future;
 }
 
 ThreadPool::~ThreadPool() {
   wait();
 }
 
 #endif