contrib/llvm/tools/lldb/source/Utility/TaskPool.cpp

   1 //===--------------------- TaskPool.cpp -------------------------*- 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 #include "lldb/Utility/TaskPool.h"
  11
  12 namespace
  13 {
  14     class TaskPoolImpl
  15     {
  16     public:
  17         static TaskPoolImpl&
  18         GetInstance();
  19
  20         void
  21         AddTask(std::function<void()>&& task_fn);
  22
  23     private:
  24         TaskPoolImpl();
  25
  26         static void
  27         Worker(TaskPoolImpl* pool);
  28
  29         std::queue<std::function<void()>> m_tasks;
  30         std::mutex                        m_tasks_mutex;
  31         uint32_t                          m_thread_count;
  32     };
  33
  34 } // end of anonymous namespace
  35
  36 TaskPoolImpl&
  37 TaskPoolImpl::GetInstance()
  38 {
  39     static TaskPoolImpl g_task_pool_impl;
  40     return g_task_pool_impl;
  41 }
  42
  43 void
  44 TaskPool::AddTaskImpl(std::function<void()>&& task_fn)
  45 {
  46     TaskPoolImpl::GetInstance().AddTask(std::move(task_fn));
  47 }
  48
  49 TaskPoolImpl::TaskPoolImpl() :
  50     m_thread_count(0)
  51 {
  52 }
  53
  54 void
  55 TaskPoolImpl::AddTask(std::function<void()>&& task_fn)
  56 {
  57     static const uint32_t max_threads = std::thread::hardware_concurrency();
  58
  59     std::unique_lock<std::mutex> lock(m_tasks_mutex);
  60     m_tasks.emplace(std::move(task_fn));
  61     if (m_thread_count < max_threads)
  62     {
  63         m_thread_count++;
  64         lock.unlock();
  65
  66         std::thread (Worker, this).detach();
  67     }
  68 }
  69
  70 void
  71 TaskPoolImpl::Worker(TaskPoolImpl* pool)
  72 {
  73     while (true)
  74     {
  75         std::unique_lock<std::mutex> lock(pool->m_tasks_mutex);
  76         if (pool->m_tasks.empty())
  77         {
  78             pool->m_thread_count--;
  79             break;
  80         }
  81
  82         std::function<void()> f = pool->m_tasks.front();
  83         pool->m_tasks.pop();
  84         lock.unlock();
  85
  86         f();
  87     }
  88 }