VuoCompilerTriggerPort.cc

Go to the documentation of this file.

 
#include "VuoCompilerCodeGenUtilities.hh"
#include "VuoCompilerTriggerPort.hh"
#include "VuoCompilerTriggerPortClass.hh"
#include "VuoCompilerType.hh"
#include "VuoPort.hh"
#include "VuoType.hh"
 
VuoCompilerTriggerPort::VuoCompilerTriggerPort(VuoPort * basePort)
    : VuoCompilerPort(basePort)
{
}
 
Value * VuoCompilerTriggerPort::generateCreatePortContext(Module *module, BasicBlock *block)
{
    VuoType *dataType = getClass()->getDataVuoType();
 
    return VuoCompilerCodeGenUtilities::generateCreatePortContext(module, block,
                                                                  dataType ? dataType->getCompiler() : nullptr,
                                                                  true, "org.vuo.composition." + getIdentifier());
}
 
void VuoCompilerTriggerPort::generateScheduleWorker(Module *module, Function *function, BasicBlock *block,
                                                    Value *compositionStateValue, Value *eventIdValue,
                                                    Value *portContextValue, VuoType *dataType,
                                                    int minThreadsNeeded, int maxThreadsNeeded, int chainCount,
                                                    Function *workerFunction)
{
    PointerType *voidPointer = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
 
    Value *dataCopyAsVoidPointer;
    if (dataType)
    {
        // Create a copy of the data on the heap.
        Value *dataPointer = dataType->getCompiler()->convertArgsToPortData(module, block, function, 0);
        dataCopyAsVoidPointer = VuoCompilerCodeGenUtilities::generateMemoryAllocation(module, block, dataType->getCompiler());
        VuoCompilerCodeGenUtilities::generateMemoryCopy(module, block, dataPointer, dataCopyAsVoidPointer, dataType->getCompiler());
 
        dataType->getCompiler()->generateRetainCall(module, block, dataCopyAsVoidPointer);
    }
    else
        dataCopyAsVoidPointer = ConstantPointerNull::get(voidPointer);
 
    // Create a copy of the event ID on the heap.
    Type *eventIdType = VuoCompilerCodeGenUtilities::generateNoEventIdConstant(module)->getType();
    Value *eventIdCopyAddress = VuoCompilerCodeGenUtilities::generateMemoryAllocation(module, block, eventIdType, 1);
    new StoreInst(eventIdValue, eventIdCopyAddress, false, block);
 
    Value *contextValue = VuoCompilerCodeGenUtilities::generateCreateTriggerWorkerContext(module, block, compositionStateValue,
                                                                                          dataCopyAsVoidPointer, eventIdCopyAddress);
 
    Value *dispatchQueueValue = VuoCompilerCodeGenUtilities::generateGetPortContextTriggerQueue(module, block, portContextValue);
 
    VuoCompilerCodeGenUtilities::generateScheduleTriggerWorker(module, block, dispatchQueueValue, contextValue, workerFunction,
                                                               minThreadsNeeded, maxThreadsNeeded,
                                                               eventIdValue, compositionStateValue, chainCount);
}
 
Function * VuoCompilerTriggerPort::generateSynchronousSubmissionToDispatchQueue(Module *module, BasicBlock *block, Value *nodeContextValue,
                                                                                string workerFunctionName, Value *workerFunctionArg)
{
    Function *workerFunction = getWorkerFunction(module, workerFunctionName);
 
    PointerType *voidPointer = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
    Value *argAsVoidPointer;
    if (workerFunctionArg)
        argAsVoidPointer = new BitCastInst(workerFunctionArg, voidPointer, "", block);
    else
        argAsVoidPointer = ConstantPointerNull::get(voidPointer);
 
    Value *portContextValue = generateGetPortContext(module, block, nodeContextValue);
    Value *dispatchQueueValue = VuoCompilerCodeGenUtilities::generateGetPortContextTriggerQueue(module, block, portContextValue);
    VuoCompilerCodeGenUtilities::generateSynchronousSubmissionToDispatchQueue(module, block, dispatchQueueValue, workerFunction, argAsVoidPointer);
 
    return workerFunction;
}
 
Function * VuoCompilerTriggerPort::getWorkerFunction(Module *module, string functionName, bool isExternal)
{
    PointerType *voidPointer = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
 
    vector<Type *> workerFunctionParams;
    workerFunctionParams.push_back(voidPointer);
    FunctionType *workerFunctionType = FunctionType::get(Type::getVoidTy(module->getContext()),
                                                         workerFunctionParams,
                                                         false);
 
    Function *workerFunction = module->getFunction(functionName);
    if (! workerFunction) {
        workerFunction = Function::Create(workerFunctionType,
                                          isExternal ? GlobalValue::ExternalLinkage : GlobalValue::InternalLinkage,
                                          functionName,
                                          module);
    }
 
    return workerFunction;
}
 
Value * VuoCompilerTriggerPort::generateNonBlockingWaitForSemaphore(Module *module, BasicBlock *block, Value *portContextValue)
{
    ConstantInt *timeoutDeltaValue = ConstantInt::get(module->getContext(), APInt(64, 0));
    Value *timeoutValue = VuoCompilerCodeGenUtilities::generateCreateDispatchTime(module, block, timeoutDeltaValue);
    Value *dispatchSemaphoreValue = VuoCompilerCodeGenUtilities::generateGetPortContextTriggerSemaphore(module, block, portContextValue);
    return VuoCompilerCodeGenUtilities::generateWaitForSemaphore(module, block, dispatchSemaphoreValue, timeoutValue);
}
 
void VuoCompilerTriggerPort::generateSignalForSemaphore(Module *module, BasicBlock *block, Value *nodeContextValue)
{
    Value *portContextValue = generateGetPortContext(module, block, nodeContextValue);
    Value *dispatchSemaphoreValue = VuoCompilerCodeGenUtilities::generateGetPortContextTriggerSemaphore(module, block, portContextValue);
    VuoCompilerCodeGenUtilities::generateSignalForSemaphore(module, block, dispatchSemaphoreValue);
}
 
Value * VuoCompilerTriggerPort::generateLoadFunction(Module *module, BasicBlock *block, Value *nodeContextValue)
{
    Value *portContextValue = generateGetPortContext(module, block, nodeContextValue);
    return VuoCompilerCodeGenUtilities::generateGetPortContextTriggerFunction(module, block, portContextValue, getClass()->getFunctionType(module));
}
 
void VuoCompilerTriggerPort::generateStoreFunction(Module *module, BasicBlock *block, Value *nodeContextValue, Value *functionValue)
{
    Value *portContextValue = generateGetPortContext(module, block, nodeContextValue);
    VuoCompilerCodeGenUtilities::generateSetPortContextTriggerFunction(module, block, portContextValue, functionValue);
}
 
Value * VuoCompilerTriggerPort::generateRetrievePreviousData(Module *module, BasicBlock *block, Value *nodeContextValue)
{
    Value *portContextValue = generateGetPortContext(module, block, nodeContextValue);
    return VuoCompilerCodeGenUtilities::generateGetPortContextDataVariable(module, block, portContextValue, getClass()->getDataVuoType()->getCompiler());
}
 
void VuoCompilerTriggerPort::generateFreeContext(Module *module, BasicBlock *block, Function *workerFunction)
{
    Value *contextValue = workerFunction->arg_begin();
    VuoCompilerCodeGenUtilities::generateFreeTriggerWorkerContext(module, block, contextValue);
}
 
Value * VuoCompilerTriggerPort::generateCompositionStateValue(Module *module, BasicBlock *block, Function *workerFunction)
{
    // VuoCompositionState *compositionState = (VuoCompositionState *)((void **)context)[0];
 
    Value *contextValue = workerFunction->arg_begin();
    Type *voidPointerType = contextValue->getType();
    Type *voidPointerPointerType = PointerType::get(voidPointerType, 0);
    Type *compositionStatePointerType = PointerType::get(VuoCompilerCodeGenUtilities::getCompositionStateType(module), 0);
 
    Value *contextValueAsVoidPointerArray = new BitCastInst(contextValue, voidPointerPointerType, "", block);
    Value *compositionStateAsVoidPointer = VuoCompilerCodeGenUtilities::generateGetArrayElement(module, block, contextValueAsVoidPointerArray, (size_t)0);
    return new BitCastInst(compositionStateAsVoidPointer, compositionStatePointerType, "", block);
}
 
Value * VuoCompilerTriggerPort::generateDataValue(Module *module, BasicBlock *block, Function *workerFunction)
{
    // PortDataType *dataCopy = (PortDataType *)((void **)context)[1]);
    // PortDataType data = *dataCopy;
 
    Value *contextValue = workerFunction->arg_begin();
    Type *voidPointerType = contextValue->getType();
    Type *voidPointerPointerType = PointerType::get(voidPointerType, 0);
 
    Value *contextValueAsVoidPointerArray = new BitCastInst(contextValue, voidPointerPointerType, "", block);
    return VuoCompilerCodeGenUtilities::generateGetArrayElement(module, block, contextValueAsVoidPointerArray, 1);
}
 
Value * VuoCompilerTriggerPort::generateEventIdValue(Module *module, BasicBlock *block, Function *workerFunction)
{
    // unsigned long *eventIdCopy = (unsigned long *)((void **)context)[2];
    // unsigned long eventId = *eventIdCopy;
 
    Value *contextValue = workerFunction->arg_begin();
    Type *voidPointerType = contextValue->getType();
    Type *voidPointerPointerType = PointerType::get(voidPointerType, 0);
    Type *eventIdType = VuoCompilerCodeGenUtilities::generateNoEventIdConstant(module)->getType();
 
    Value *contextValueAsVoidPointerArray = new BitCastInst(contextValue, voidPointerPointerType, "", block);
    Value *eventIdCopyAsVoidPointer = VuoCompilerCodeGenUtilities::generateGetArrayElement(module, block, contextValueAsVoidPointerArray, 2);
    PointerType *pointerToEventIdType = PointerType::get(eventIdType, 0);
    Value *eventIdCopyValue = new BitCastInst(eventIdCopyAsVoidPointer, pointerToEventIdType, "", block);
    return new LoadInst(eventIdCopyValue, "", block);
}
 
Value * VuoCompilerTriggerPort::generateDataValueUpdate(Module *module, BasicBlock *block, Function *workerFunction, Value *nodeContextValue)
{
    Value *currentDataValue = NULL;
    VuoType *dataType = getClass()->getDataVuoType();
 
    if (dataType)
    {
        // Load the previous data.
        Value *previousDataPointer = generateRetrievePreviousData(module, block, nodeContextValue);
 
        // Load the current data.
        Value *currentDataVoidPointer = generateDataValue(module, block, workerFunction);
        Value *currentDataPointer = dataType->getCompiler()->convertToPortData(block, currentDataVoidPointer);
        currentDataValue = new LoadInst(currentDataPointer, "", block);
 
        // The current data becomes the previous data.
        dataType->getCompiler()->generateReleaseCall(module, block, previousDataPointer);
        Value *portContextValue = generateGetPortContext(module, block, nodeContextValue);
        VuoCompilerCodeGenUtilities::generateSetPortContextData(module, block, portContextValue, currentDataValue, dataType->getCompiler());
    }
 
    return currentDataValue;
}
 
void VuoCompilerTriggerPort::generateDataValueDiscardFromScheduler(Module *module, Function *function, BasicBlock *block,
                                                                   VuoType *dataType)
{
    Value *dataPointer = dataType->getCompiler()->convertArgsToPortData(module, block, function, 0);
    dataType->getCompiler()->generateRetainCall(module, block, dataPointer);
    dataType->getCompiler()->generateReleaseCall(module, block, dataPointer);
}
 
void VuoCompilerTriggerPort::generateDataValueDiscardFromWorker(Module *module, BasicBlock *block, Function *workerFunction)
{
    VuoType *dataType = getClass()->getDataVuoType();
 
    if (dataType)
    {
        Value *dataValue = generateDataValue(module, block, workerFunction);
        dataValue = dataType->getCompiler()->convertToPortData(block, dataValue);
        dataType->getCompiler()->generateReleaseCall(module, block, dataValue);
    }
}
 
VuoCompilerTriggerPortClass * VuoCompilerTriggerPort::getClass(void)
{
    return (VuoCompilerTriggerPortClass *)(getBase()->getClass()->getCompiler());
}