TaskManager.cpp

Go to the documentation of this file.

#include "Application.hpp"


manual_reset_event::manual_reset_event(bool signaled)
    : m_signaled(signaled)
{ }

void manual_reset_event::signal()
{
    {
        lock_guard<mutex> lock(m_mutex);
        m_signaled = true;
    }

    m_cv.notify_all();
}

void manual_reset_event::reset()
{
    lock_guard<mutex> lock(m_mutex);
    m_signaled = false;
}


void manual_reset_event::wait()
{
    unique_lock<mutex> lock(m_mutex);

    while (!m_signaled)
        m_cv.wait(lock);
}




auto_reset_event::auto_reset_event()
    : m_signal(0)
{ }

void auto_reset_event::signal()
{
    {
        lock_guard<mutex> lock(m_mutex);
        m_signal++;
            
        m_cv.notify_one();
    }
}

void auto_reset_event::signalN(uint n)
{
    {
        lock_guard<mutex> lock(m_mutex);
        m_signal += n;
            
        m_cv.notify_all();
    }
}


void auto_reset_event::wait(uint nTimes)
{
    unique_lock<mutex> lock(m_mutex);

    m_cv.wait(lock, [this, nTimes]() { return m_signal >= nTimes; });
    m_signal -= nTimes;
}




TaskManager::TaskManager(Application* app)
{
    auto const threadCount = app->getConfig().threadpoolSize();
    
    cout << "Threadpool-Size: " << threadCount << endl;
        
    m_threadKeepAlive.reserve(threadCount);
    m_threads.reserve(threadCount);

    for (size_t i = 0; i < threadCount; i++)
    {
        m_threadKeepAlive.push_back(true);
        m_threads.push_back(thread(&TaskManager::worker, this, &(m_threadKeepAlive[i])));
    }
}
TaskManager::~TaskManager()
{
    for (size_t i = 0; i < m_threads.size(); i++)
        m_threadKeepAlive[i] = false;

    for (size_t i = 0; i < m_threads.size(); i++)
        m_threadHasTodo.signalN(4);

    for (auto& thread : m_threads)
        thread.join();
}

void TaskManager::worker(BOOL* keepAlive)
{
    function<void()> task;

    while (*keepAlive)
    {
        m_threadHasTodo.wait();
            
        if (m_taskqueue.try_pop(task))
            task();
    }
}