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()->getType() : NULL,
                                                                  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)
    {
        // PortDataType_retain(data);
        // PortDataType *dataCopy = (void *)malloc(sizeof(VuoImage));
        // *dataCopy = data;
        Value *dataValue = VuoCompilerCodeGenUtilities::unlowerArgument(dataType->getCompiler(), function, 0, module, block);
        dataType->getCompiler()->generateRetainCall(module, block, dataValue);
        ConstantInt *oneValue = ConstantInt::get(module->getContext(), APInt(64, 1));
        Value *dataCopyAddress = VuoCompilerCodeGenUtilities::generateMemoryAllocation(module, block, dataType->getCompiler()->getType(), oneValue);
        new StoreInst(dataValue, dataCopyAddress, false, block);
        dataCopyAsVoidPointer = new BitCastInst(dataCopyAddress, voidPointer, "", block);
    }
    else
    {
        dataCopyAsVoidPointer = ConstantPointerNull::get(voidPointer);
    }
 
    // unsigned long *eventIdCopy = (unsigned long *)malloc(sizeof(unsigned long));
    // *eventIdCopy = eventId;
    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());
}
 
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::generateLoadPreviousData(Module *module, BasicBlock *block, Value *nodeContextValue)
{
    Value *portContextValue = generateGetPortContext(module, block, nodeContextValue);
    return VuoCompilerCodeGenUtilities::generateGetPortContextData(module, block, portContextValue, getDataType());
}
 
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);
    Value *dataCopyAsVoidPointer = VuoCompilerCodeGenUtilities::generateGetArrayElement(module, block, contextValueAsVoidPointerArray, 1);
    PointerType *pointerToDataType = PointerType::get(getDataType(), 0);
    Value *dataCopyValue = new BitCastInst(dataCopyAsVoidPointer, pointerToDataType, "", block);
    return new LoadInst(dataCopyValue, "", block);
}
 
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;
    Type *dataType = getDataType();
 
    if (dataType)
    {
        // Load the previous data.
        Value *portContextValue = generateGetPortContext(module, block, nodeContextValue);
        Value *previousDataValue = VuoCompilerCodeGenUtilities::generateGetPortContextData(module, block, portContextValue, dataType);
 
        // Load the current data.
        //
        // PortDataType *dataCopy = (PortDataType *)((void **)context)[1]);
        // PortDataType data = *dataCopy;
        currentDataValue = generateDataValue(module, block, workerFunction);
 
        // The current data becomes the previous data.
        //
        // PortDataType_release(previousData);
        // previousData = data;
        VuoCompilerCodeGenUtilities::generateSetPortContextData(module, block, portContextValue, currentDataValue);
        VuoCompilerType *type = getClass()->getDataVuoType()->getCompiler();
        type->generateReleaseCall(module, block, previousDataValue);
    }
 
    return currentDataValue;
}
 
void VuoCompilerTriggerPort::generateDataValueDiscardFromScheduler(Module *module, Function *function, BasicBlock *block,
                                                                   VuoType *dataType)
{
    Value *dataValue = VuoCompilerCodeGenUtilities::unlowerArgument(dataType->getCompiler(), function, 0, module, block);
    dataType->getCompiler()->generateRetainCall(module, block, dataValue);
    dataType->getCompiler()->generateReleaseCall(module, block, dataValue);
}
 
void VuoCompilerTriggerPort::generateDataValueDiscardFromWorker(Module *module, BasicBlock *block, Function *workerFunction)
{
    VuoType *dataType = getClass()->getDataVuoType();
 
    if (dataType)
    {
        Value *dataValue = generateDataValue(module, block, workerFunction);
        dataType->getCompiler()->generateReleaseCall(module, block, dataValue);
    }
}
 
Type * VuoCompilerTriggerPort::getDataType(void)
{
    VuoType *vuoType = getClass()->getDataVuoType();
    return (vuoType == NULL ? NULL : vuoType->getCompiler()->getType());
}
 
VuoCompilerTriggerPortClass * VuoCompilerTriggerPort::getClass(void)
{
    return (VuoCompilerTriggerPortClass *)(getBase()->getClass()->getCompiler());
}