ThreadPool.h

#ifndef NTA_THREADPOOL_H_INCLUDED
#define NTA_THREADPOOL_H_INCLUDED
 
#include <thread>
#include <atomic>
#include <queue>
#include <mutex>
#include <functional>
#include <condition_variable>
 
typedef std::function<void(void)> Thunk;
 
namespace nta {
    namespace utils {
        class Semaphore {
        private:
            std::mutex m_mutex;
            std::condition_variable_any m_cv;
            int m_value;
        public:
            Semaphore(int value = 0);
            void wait();
            void signal();
 
            Semaphore(const Semaphore&) = delete;
            const Semaphore& operator=(const Semaphore&) = delete;
        };
        class ThreadPool {
        private:
            struct worker {
                std::thread t;
                Thunk thunk;
                std::atomic<bool> free;
                // Notifies worker when it has a new task
                Semaphore task;
 
                worker() : free(true) {}
            };
 
            void dispatcher();
            void worker_func(size_t wid);
            size_t getAvailableWorker();
            bool allWorkFinished();
 
            struct {
                std::condition_variable_any cv;
                std::mutex m;
            } m_empty;
            std::vector<worker> m_workers;
            std::atomic<bool> m_kill;
            Semaphore m_scheduled;
            Semaphore m_available;
            std::queue<Thunk> m_funcs;
            std::thread m_dispatch_thread;
        public:
            ThreadPool(size_t num_threads);
            ~ThreadPool();
            void schedule(const Thunk& thunk);
            void wait();
 
            ThreadPool(const ThreadPool&) = delete;
            ThreadPool& operator=(const ThreadPool&) = delete;
        };
    }
}
 
#endif // NTA_THREADPOOL_H_INCLUDED