Jobs.hpp

#ifndef JOB_HPP
#define JOB_HPP
#include "pch.hpp"
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
 
namespace Engine {
 
  const uint8_t MAX_JOB_THREADS = 3;
 
  typedef std::function<void(void)> func;
 
  class JobSystem {
    private:
      std::vector<std::thread> m_Threads;
 
      std::mutex mu;
 
      std::condition_variable m_Condition;
 
      std::queue<func> m_Tasks;
 
      bool quit;
 
    public:
      JobSystem() = delete;
 
      JobSystem(size_t num_threads) : quit(false) {
        for (size_t i = 0; i <= num_threads; ++i) {
          // make sure that we are not exceeding the max number of job threads
          assert(num_threads <= MAX_JOB_THREADS);
          m_Threads.emplace_back(
              [this] {
              for(;;) {
                // current task
                std::function<void()> task;
 
                {
                  // block thread until either we are quitting or there is a task available
                  std::unique_lock<std::mutex> lock(this->mu);
                  this->m_Condition.wait(lock,
                    [this]{ return this->quit || !this->m_Tasks.empty(); });
                  // if we're quitting then bail out
                  if(this->quit)
                    return;
 
                  // get the oldest task
                  task = std::move(this->m_Tasks.front());
                  // remove it
                  this->m_Tasks.pop();
                }
                  // execute the task
                  task();
              }
              });
        }
      }
 
      void Stop() {
 
        // lock the mutex and set quit to true
        { std::unique_lock<std::mutex> lock(mu);
          quit = true; }
 
        // tell all the worker threads
        m_Condition.notify_all();
        for(std::thread &worker: m_Threads)
          worker.join();
      }
 
      ~JobSystem() {
        if (!quit)
          Stop();
      }
 
      void AddJob(func job) {
        {
          std::unique_lock<std::mutex> lock(mu);
 
          // don't allow enqueueing after stopping the pool
          if(quit)
            throw std::runtime_error("enqueue on stopped JobSystem");
 
          m_Tasks.emplace([job](){ job(); });
        }
        m_Condition.notify_one();
      }
 
  };
}
 
#endif