VuoModuleCompilationQueue.cc

Go to the documentation of this file.

 
#include "VuoModuleCompilationQueue.hh"
 
const int VuoModuleCompilationQueue::maxConcurrentCompilations = 8;
 
VuoModuleCompilationQueue::Item::Item()
{
    sourceFile = nullptr;
    loadingGroup = nullptr;
}
 
bool VuoModuleCompilationQueue::Item::hasHigherPriority(Item *other)
{
    return (priority.first != other->priority.first ?
                                  (priority.first < other->priority.first) :
                                  (priority.second < other->priority.second));
}
 
VuoModuleCompilationQueue::VuoModuleCompilationQueue()
{
}
 
void VuoModuleCompilationQueue::enqueue(VuoModuleCompilationQueue::Item *item)
{
    std::unique_lock<std::mutex> lock(queueMutex);
 
    queue[item->sourcePath].push_back({item, false});
}
 
VuoModuleCompilationQueue::Item * VuoModuleCompilationQueue::next()
{
    Item *item = nullptr;
 
    std::unique_lock<std::mutex> lock(queueMutex);
    queueChanged.wait(lock, [this, &item]()
    {
        int concurrentCompilations = 0;
 
        // Select the highest-priority item that is not already being compiled (if any).
        auto selectedIter = queue.end();
        for (auto i = queue.begin(); i != queue.end(); ++i)
        {
            if (! ripeItemIsCompiling(i) &&
                    (selectedIter == queue.end() || ripeItem(i)->hasHigherPriority(ripeItem(selectedIter))))
                selectedIter = i;
 
            if (ripeItemIsCompiling(i))
                ++concurrentCompilations;
        }
 
        // If an item was selected and we haven't already reached the limit of concurrent compilations, return the item.
        if (selectedIter != queue.end() && concurrentCompilations < maxConcurrentCompilations)
        {
            item = ripeItem(selectedIter);
            ripeItemIsCompiling(selectedIter) = true;
            return true;
        }
 
        return false;
    });
 
    return item;
}
 
void VuoModuleCompilationQueue::completed(VuoModuleCompilationQueue::Item *item)
{
    std::unique_lock<std::mutex> lock(queueMutex);
 
    auto i = queue.find(item->sourcePath);
    pluckRipeItem(i);
 
    queueChanged.notify_one();
}
 
VuoModuleCompilationQueue::Item * VuoModuleCompilationQueue::ripeItem(map<string, list< pair<Item *, bool> > >::iterator iter)
{
    return iter->second.front().first;
}
 
bool& VuoModuleCompilationQueue::ripeItemIsCompiling(map<string, list< pair<Item *, bool> > >::iterator iter)
{
    return iter->second.front().second;
}
 
void VuoModuleCompilationQueue::pluckRipeItem(map<string, list< pair<Item *, bool> > >::iterator iter)
{
    delete iter->second.front().first;
    iter->second.pop_front();
 
    if (iter->second.empty())
        queue.erase(iter);
}