VuoRuntimeContext.cc

Go to the documentation of this file.

 
#include "VuoRuntimeContext.hh"
#include "VuoEventLoop.h"
#include <mutex>
#include <condition_variable>
 
struct PortContext * vuoCreatePortContext(void *data, bool isTrigger, const char *triggerQueueName)
{
    struct PortContext *portContext = (struct PortContext *)malloc(sizeof(struct PortContext));
    portContext->event = false;
    portContext->data = data;
    portContext->dataRetained = false;
    portContext->triggerFunction = NULL;
    portContext->eventBlocking = PortContext_EventBlocking_NotApplicable;
 
    if (isTrigger)
    {
        portContext->triggerQueue = dispatch_queue_create(triggerQueueName, VuoEventLoop_getDispatchInteractiveAttribute());
        portContext->triggerSemaphore = dispatch_semaphore_create(1);
    }
    else
    {
        portContext->triggerQueue = NULL;
        portContext->triggerSemaphore = NULL;
    }
 
    return portContext;
}
 
struct NodeContext * vuoCreateNodeContext(bool hasInstanceData, bool isComposition, size_t outputEventCount)
{
    struct NodeContext *nodeContext = (struct NodeContext *)malloc(sizeof(struct NodeContext));
    nodeContext->portContexts = NULL;
    nodeContext->portContextCount = 0;
    nodeContext->nodeMutex = new std::mutex();
    nodeContext->nodeConditionVariable = new std::condition_variable();
    nodeContext->claimingEventId = 0;
 
    if (isComposition)
    {
        nodeContext->executingEventIds = new vector<unsigned long>();
        nodeContext->executingGroup = dispatch_group_create();
        nodeContext->outputEvents = (bool *)calloc(outputEventCount, sizeof(bool));
        nodeContext->executingEventIdsSync = new std::mutex();
    }
    else
    {
        nodeContext->executingEventIds = NULL;
        nodeContext->executingGroup = NULL;
        nodeContext->outputEvents = NULL;
        nodeContext->executingEventIdsSync = NULL;
    }
 
    if (hasInstanceData)
    {
        void **instanceData = (void **)malloc(sizeof(void *));
        *instanceData = NULL;
        nodeContext->instanceData = (void *)instanceData;
    }
    else
        nodeContext->instanceData = NULL;
 
    return nodeContext;
}
 
void vuoFreePortContext(struct PortContext *portContext)
{
    if (! portContext->dataRetained)
        free(portContext->data);
    if (portContext->triggerQueue)
        dispatch_release(portContext->triggerQueue);
    if (portContext->triggerSemaphore)
        dispatch_release(portContext->triggerSemaphore);
    free(portContext);
}
 
void vuoFreeNodeContext(struct NodeContext *nodeContext)
{
    for (size_t i = 0; i < nodeContext->portContextCount; ++i)
        vuoFreePortContext(nodeContext->portContexts[i]);
 
    free(nodeContext->portContexts);
    free(nodeContext->instanceData);
    delete static_cast<std::mutex *>(nodeContext->nodeMutex);
    delete static_cast<std::condition_variable *>(nodeContext->nodeConditionVariable);
    delete static_cast< vector<unsigned long> *>(nodeContext->executingEventIds);
    if (nodeContext->executingGroup)
        dispatch_release(nodeContext->executingGroup);
    free(nodeContext->outputEvents);
    delete static_cast<std::mutex *>(nodeContext->executingEventIdsSync);
    free(nodeContext);
}
 
void vuoSetPortContextEvent(struct PortContext *portContext, bool event)
{
    portContext->event = event;
}
 
void vuoSetPortContextData(struct PortContext *portContext, void *data)
{
    portContext->data = data;
}
 
void vuoSetPortContextTriggerFunction(struct PortContext *portContext, void *triggerFunction)
{
    portContext->triggerFunction = triggerFunction;
}
 
void vuoSetPortContextEventBlocking(struct PortContext *portContext, PortContext_EventBlocking eventBlocking)
{
    portContext->eventBlocking = eventBlocking;
}
 
bool vuoGetPortContextEvent(struct PortContext *portContext)
{
    return portContext->event;
}
 
void * vuoGetPortContextData(struct PortContext *portContext)
{
    return portContext->data;
}
 
dispatch_queue_t vuoGetPortContextTriggerQueue(struct PortContext *portContext)
{
    return portContext->triggerQueue;
}
 
dispatch_semaphore_t vuoGetPortContextTriggerSemaphore(struct PortContext *portContext)
{
    return portContext->triggerSemaphore;
}
 
void * vuoGetPortContextTriggerFunction(struct PortContext *portContext)
{
    return portContext->triggerFunction;
}
 
void vuoRetainPortContextData(struct PortContext *portContext)
{
    portContext->dataRetained = true;
}
 
void vuoSetNodeContextPortContexts(struct NodeContext *nodeContext, struct PortContext **portContexts, unsigned long portContextCount)
{
    nodeContext->portContexts = portContexts;
    nodeContext->portContextCount = portContextCount;
}
 
void vuoSetNodeContextInstanceData(struct NodeContext *nodeContext, void *instanceData)
{
    free(nodeContext->instanceData);
    nodeContext->instanceData = instanceData;
}
 
void vuoSetNodeContextClaimingEventId(struct NodeContext *nodeContext, unsigned long claimingEventId)
{
    nodeContext->claimingEventId = claimingEventId;
}
 
void vuoSetNodeContextOutputEvent(struct NodeContext *nodeContext, size_t index, bool event)
{
    nodeContext->outputEvents[index] = event;
}
 
struct PortContext * vuoGetNodeContextPortContext(struct NodeContext *nodeContext, size_t index)
{
    return nodeContext->portContexts[index];
}
 
void * vuoGetNodeContextInstanceData(struct NodeContext *nodeContext)
{
    return nodeContext->instanceData;
}
 
unsigned long vuoGetNodeContextClaimingEventId(struct NodeContext *nodeContext)
{
    return nodeContext->claimingEventId;
}
 
dispatch_group_t vuoGetNodeContextExecutingGroup(struct NodeContext *nodeContext)
{
    return nodeContext->executingGroup;
}
 
bool vuoGetNodeContextOutputEvent(struct NodeContext *nodeContext, size_t index)
{
    return nodeContext->outputEvents[index];
}
 
bool vuoEventHitAnyInputPort(NodeContext *nodeContext)
{
    for (unsigned long i = 0; i < nodeContext->portContextCount; ++i)
    {
        PortContext *portContext = nodeContext->portContexts[i];
        if (portContext->eventBlocking != PortContext_EventBlocking_NotApplicable && portContext->event)
            return true;
    }
 
    return false;
}
 
bool vuoEventHitInputPort(NodeContext *nodeContext, PortContext_EventBlocking eligibleEventBlocking)
{
    for (unsigned long i = 0; i < nodeContext->portContextCount; ++i)
    {
        PortContext *portContext = nodeContext->portContexts[i];
        if (portContext->eventBlocking == eligibleEventBlocking && portContext->event)
            return true;
    }
 
    return false;
}
 
void vuoSetOutputEventsAfterNodeExecution(NodeContext *nodeContext)
{
    bool eventHitNonBlockingInput = vuoEventHitInputPort(nodeContext, PortContext_EventBlocking_None);
    bool eventHitDoorInput = vuoEventHitInputPort(nodeContext, PortContext_EventBlocking_Door);
 
    if (eventHitNonBlockingInput || ! eventHitDoorInput)
    {
        for (unsigned long i = 0; i < nodeContext->portContextCount; ++i)
        {
            PortContext *portContext = nodeContext->portContexts[i];
            if (portContext->eventBlocking == PortContext_EventBlocking_NotApplicable)
                portContext->event = eventHitNonBlockingInput;
        }
    }
}
 
void vuoResetNodeContextEvents(struct NodeContext *nodeContext)
{
    for (size_t i = 0; i < nodeContext->portContextCount; ++i)
        nodeContext->portContexts[i]->event = false;
}
 
void vuoStartedExecutingEvent(struct NodeContext *nodeContext, unsigned long eventId)
{
    std::lock_guard<std::mutex> guard(*static_cast<std::mutex *>(nodeContext->executingEventIdsSync));
 
    vector<unsigned long> *executingEventIds = static_cast< vector<unsigned long> *>(nodeContext->executingEventIds);
    executingEventIds->clear();
    executingEventIds->push_back(eventId);
}
 
void vuoSpunOffExecutingEvent(struct NodeContext *nodeContext, unsigned long eventId)
{
    std::lock_guard<std::mutex> guard(*static_cast<std::mutex *>(nodeContext->executingEventIdsSync));
 
    vector<unsigned long> *executingEventIds = static_cast< vector<unsigned long> *>(nodeContext->executingEventIds);
    if (! executingEventIds->empty())
        executingEventIds->push_back(eventId);
}
 
bool vuoFinishedExecutingEvent(struct NodeContext *nodeContext, unsigned long eventId)
{
    std::lock_guard<std::mutex> guard(*static_cast<std::mutex *>(nodeContext->executingEventIdsSync));
 
    vector<unsigned long> *executingEventIds = static_cast< vector<unsigned long> *>(nodeContext->executingEventIds);
    auto found = find(executingEventIds->begin(), executingEventIds->end(), eventId);
    if (found != executingEventIds->end())
    {
        executingEventIds->erase(found);
        return executingEventIds->empty();
    }
    return false;
}
 
unsigned long vuoGetOneExecutingEvent(struct NodeContext *nodeContext)
{
    std::lock_guard<std::mutex> guard(*static_cast<std::mutex *>(nodeContext->executingEventIdsSync));
 
    vector<unsigned long> *executingEventIds = static_cast< vector<unsigned long> *>(nodeContext->executingEventIds);
    return executingEventIds->at(0);
}