job_runner.h

// This file if part of the llir-opt project.
// Licensing information can be found in the LICENSE file.
// (C) 2018 Nandor Licker. All rights reserved.
 
#pragma once
 
#include <atomic>
#include <thread>
 
#include "timeout.h"
 
 
 
template <typename Task, typename Result>
class JobRunner {
public:
  JobRunner(unsigned threadCount = 1) : threadCount_(threadCount) {}
 
  virtual ~JobRunner()
  {
  }
 
  void Execute(const Timeout &timeout)
  {
    std::vector<std::thread> threads;
    for (unsigned i = 0; i < threadCount_; ++i) {
      threads.emplace_back([this, &timeout] {
        while (true) {
          // If timeout reached, break.
          if (timeout) {
            return;
          }
 
          // Get a new task to execute.
          Task task;
          {
            std::lock_guard<std::mutex> guard(lock_);
            if (auto newTask = Request()) {
              task = std::move(*newTask);
            } else {
              return;
            }
          }
 
          // Run the task.
          Result result = Run(std::move(task));
 
          // Post the result.
          {
            std::lock_guard<std::mutex> guard(lock_);
            Post(std::move(result));
          }
        }
      });
    }
 
    for (std::thread &thread : threads) {
      thread.join();
    }
  }
 
protected:
  virtual std::optional<Task> Request() = 0;
 
  virtual Result Run(Task &&task) = 0;
 
  virtual void Post(Result &&result) = 0;
 
private:
  unsigned threadCount_;
  std::mutex lock_;
};