VuoCompilerBitcodeGenerator.cc

Go to the documentation of this file.

 
#include <sstream>
#include "VuoCable.hh"
#include "VuoCompiler.hh"
#include "VuoCompilerBitcodeGenerator.hh"
#include "VuoCompilerCable.hh"
#include "VuoCompilerChain.hh"
#include "VuoCompilerCodeGenUtilities.hh"
#include "VuoCompilerConstantsCache.hh"
#include "VuoCompilerComposition.hh"
#include "VuoCompilerGraph.hh"
#include "VuoCompilerInputDataClass.hh"
#include "VuoCompilerInputEventPort.hh"
#include "VuoCompilerInputEventPortClass.hh"
#include "VuoCompilerNode.hh"
#include "VuoCompilerNodeClass.hh"
#include "VuoCompilerOutputEventPort.hh"
#include "VuoCompilerPublishedPort.hh"
#include "VuoCompilerTriggerDescription.hh"
#include "VuoCompilerTriggerPort.hh"
#include "VuoCompilerTriggerPortClass.hh"
#include "VuoCompilerType.hh"
#include "VuoComposition.hh"
#include "VuoCompositionMetadata.hh"
#include "VuoNode.hh"
#include "VuoNodeClass.hh"
#include "VuoStringUtilities.hh"
#include "VuoPublishedPort.hh"
#include "VuoType.hh"
 
VuoCompilerBitcodeGenerator * VuoCompilerBitcodeGenerator::newBitcodeGeneratorFromComposition(VuoCompilerComposition *composition,
                                                                                              bool isTopLevelComposition,
                                                                                              string moduleKey, VuoCompiler *compiler)
{
    VuoCompilerBitcodeGenerator * cg = new VuoCompilerBitcodeGenerator(composition, isTopLevelComposition, moduleKey, compiler);
    return cg;
}
 
VuoCompilerBitcodeGenerator::VuoCompilerBitcodeGenerator(VuoCompilerComposition *composition,
                                                         bool isTopLevelComposition,
                                                         string moduleKey, VuoCompiler *compiler)
{
#if VUO_PRO
    VuoCompilerBitcodeGenerator_Pro();
#endif
    module = nullptr;
    constantsCache = nullptr;
 
    this->composition = composition;
    this->isTopLevelComposition = isTopLevelComposition;
    this->moduleKey = moduleKey;
    this->compiler = compiler;
 
    graph = composition->getCachedGraph(compiler);
 
    chainsForTrigger = graph->getChains();  // store in a data member, rather than calling getChains() multiple times, to preserve order of chains
    makeOrderedNodes();
    makeOrderedTypes();
    makePortContextInfo();
    makeSubcompositionModelPorts();
    makeDependencies();
}
 
VuoCompilerBitcodeGenerator::~VuoCompilerBitcodeGenerator(void)
{
    for (vector<VuoPort *>::iterator i = modelOutputPorts.begin(); i != modelOutputPorts.end(); ++i)
    {
        VuoPort *modelOutputPort = *i;
        if (modelOutputPort->getClass()->getPortType() == VuoPortClass::triggerPort)
        {
            delete modelOutputPort->getClass()->getCompiler();
            delete modelOutputPort->getCompiler();
        }
    }
}
 
struct ChainSort
{
    VuoCompilerGraph *graph;  
    VuoCompilerTriggerPort *trigger;  
    set<VuoCompilerNode *> lastNodeInLoop;  
 
    bool operator() (const vector<VuoCompilerNode *> &chainNodes1, const vector<VuoCompilerNode *> &chainNodes2)
    {
        // If the chains have an upstream-downstream relationship, return whether chainNodes1 is upstream of chainNodes2.
 
        vector<VuoCompilerNode *> downstreamOfChain1 = graph->getNodesDownstream(chainNodes1.back(), trigger);
        vector<VuoCompilerNode *> downstreamOfChain2 = graph->getNodesDownstream(chainNodes2.back(), trigger);
 
        bool isNode2DownstreamOfNode1 = find(downstreamOfChain1.begin(), downstreamOfChain1.end(), chainNodes2.front()) != downstreamOfChain1.end();
        bool isNode1DownstreamOfNode2 = find(downstreamOfChain2.begin(), downstreamOfChain2.end(), chainNodes1.front()) != downstreamOfChain2.end();
 
        if (isNode2DownstreamOfNode1 && isNode1DownstreamOfNode2)
            return (lastNodeInLoop.find(chainNodes1.front()) != lastNodeInLoop.end());
        else if (isNode2DownstreamOfNode1)
            return true;
        else if (isNode1DownstreamOfNode2)
            return false;
 
        // If at least one of the chains contains a trigger port, return the chain containing the trigger port with
        // the greatest number of downstream nodes.
 
        size_t maxNumDownstreamOfTrigger[2] = { 0, 0 };
        vector<VuoCompilerNode *> chainNodes[2] = { chainNodes1, chainNodes2 };
        for (int i = 0; i < 2; ++i)
        {
            for (vector<VuoCompilerNode *>::const_iterator j = chainNodes[i].begin(); j != chainNodes[i].end(); ++j)
            {
                VuoCompilerNode *node = *j;
                vector<VuoPort *> outputPorts = node->getBase()->getOutputPorts();
                for (vector<VuoPort *>::iterator k = outputPorts.begin(); k != outputPorts.end(); ++k)
                {
                    VuoPort *outputPort = *k;
                    if (outputPort->getClass()->getPortType() == VuoPortClass::triggerPort)
                    {
                        VuoCompilerTriggerPort *trigger = dynamic_cast<VuoCompilerTriggerPort *>( outputPort->getCompiler() );
                        size_t numDownstreamOfTrigger = graph->getNodesDownstream(trigger).size();
                        maxNumDownstreamOfTrigger[i] = max(maxNumDownstreamOfTrigger[i], numDownstreamOfTrigger);
                    }
                }
            }
        }
 
        if (maxNumDownstreamOfTrigger[0] != maxNumDownstreamOfTrigger[1])
            return maxNumDownstreamOfTrigger[0] > maxNumDownstreamOfTrigger[1];
 
        // Tiebreak: Sort alphabetically.
 
        return chainNodes1.front()->getIdentifier() < chainNodes2.front()->getIdentifier();
    }
};
 
void VuoCompilerBitcodeGenerator::makeOrderedNodes(void)
{
    // For each trigger, put its downstream nodes into topological order (optimized with ChainSort so that
    // orderedNodes will be more likely to match the ordering of the triggers with more downstream nodes).
    for (VuoCompilerTriggerPort *trigger : graph->getTriggerPorts())
    {
        vector<VuoCompilerChain *> chains;
        map<VuoCompilerTriggerPort *, vector<VuoCompilerChain *> >::iterator chainsIter = chainsForTrigger.find(trigger);
        if (chainsIter != chainsForTrigger.end())
            chains = chainsIter->second;
 
        vector< vector<VuoCompilerNode *> > chainNodeLists;
        set<VuoCompilerNode *> lastNodeInLoop;
        for (VuoCompilerChain *chain : chains)
        {
            if (chain->isLastNodeInLoop())
                lastNodeInLoop.insert( chain->getNodes().front() );
            else
                chainNodeLists.push_back( chain->getNodes() );
        }
 
        ChainSort c;
        c.graph = graph;
        c.trigger = trigger;
        c.lastNodeInLoop = lastNodeInLoop;
        sort(chainNodeLists.begin(), chainNodeLists.end(), c);
 
        vector<VuoCompilerNode *> orderedNodeList;
 
        VuoCompilerNode *triggerNode = graph->getNodeForTriggerPort(trigger);
        orderedNodeList.push_back(triggerNode);
 
        for (vector<VuoCompilerNode *> chainNodeList : chainNodeLists)
        {
            auto triggerNodeIter = std::find(chainNodeList.begin(), chainNodeList.end(), triggerNode);
            if (triggerNodeIter != chainNodeList.end())
                chainNodeList.erase(triggerNodeIter);
 
            orderedNodeList.insert( orderedNodeList.end(), chainNodeList.begin(), chainNodeList.end() );
        }
 
        downstreamNodesForTrigger[trigger] = orderedNodeList;
    }
 
    vector< vector<VuoCompilerNode *> > orderedNodesPerTrigger;
    for (const map<VuoCompilerTriggerPort *, vector<VuoCompilerNode *> >::value_type &i : downstreamNodesForTrigger)
        orderedNodesPerTrigger.push_back(i.second);
 
    // For each node that can transmit without an event, put it and its downstream nodes in with the triggers' downstream nodes.
    for (VuoCompilerNode *node : graph->getNodes())
    {
        if (graph->mayTransmitDataOnly(node))
        {
            vector<VuoCompilerNode *> downstreamNodes = graph->getNodesDownstreamViaDataOnlyTransmission(node);
            vector<VuoCompilerNode *> nodesInProgress;
            nodesInProgress.push_back(node);
            nodesInProgress.insert(nodesInProgress.end(), downstreamNodes.begin(), downstreamNodes.end());
            orderedNodesPerTrigger.push_back(nodesInProgress);
        }
    }
 
    // Put the downstream nodes per trigger in descending order of number of downstream nodes.
    std::sort(orderedNodesPerTrigger.begin(), orderedNodesPerTrigger.end(),
        [](const vector<VuoCompilerNode *> &nodes1, const vector<VuoCompilerNode *> &nodes2) {
            if (nodes1.size() != nodes2.size())
                return nodes1.size() < nodes2.size();
 
            // Tiebreak: Sort alphabetically.
            ostringstream oss1;
            ostringstream oss2;
            for (VuoCompilerNode *n : nodes1)
                oss1 << n->getIdentifier() << " ";
            for (VuoCompilerNode *n : nodes2)
                oss2 << n->getIdentifier() << " ";
            return oss1.str() < oss2.str();
        });
 
    // Visit each trigger, in descending order of number of downstream nodes (so that orderedNodes will be more likely
    // to match the ordering of the triggers with more downstream nodes, and thus be more likely to wait on them one at
    // a time instead of less efficiently having to wait on all initially).
    int previousTriggerNodeIndex = -1;
    for (vector< vector<VuoCompilerNode *> >::reverse_iterator i = orderedNodesPerTrigger.rbegin(); i != orderedNodesPerTrigger.rend(); ++i)
    {
        // Merge the trigger's downstream nodes into orderedNodes.
        int previousNodeIndex = previousTriggerNodeIndex;
        bool isFirstNode = true;
        for (VuoCompilerNode *node : *i)
        {
            vector<VuoCompilerNode *>::iterator nodeIter = find(orderedNodes.begin(), orderedNodes.end(), node);
            if (nodeIter == orderedNodes.end())
                nodeIter = orderedNodes.insert(orderedNodes.begin() + previousNodeIndex + 1, node);
 
            previousNodeIndex = max(previousNodeIndex, (int)(nodeIter - orderedNodes.begin()));
            if (isFirstNode)
            {
                previousTriggerNodeIndex = previousNodeIndex;
                isFirstNode = false;
            }
        }
    }
 
    // Add (at the end) any remaining nodes in the composition.
    for (VuoCompilerNode *node : graph->getNodes())
        if (find(orderedNodes.begin(), orderedNodes.end(), node) == orderedNodes.end())
            orderedNodes.push_back(node);
 
    for (size_t i = 0; i < orderedNodes.size(); ++i)
        orderedNodes[i]->setIndexInOrderedNodes(i);
}
 
void VuoCompilerBitcodeGenerator::sortNodes(vector<VuoCompilerNode *> &nodes)
{
    vector<VuoCompilerNode *> sortedNodes;
    for (vector<VuoCompilerNode *>::iterator i = orderedNodes.begin(); i != orderedNodes.end(); ++i)
    {
        VuoCompilerNode *node = *i;
        if (find(nodes.begin(), nodes.end(), node) != nodes.end())
            sortedNodes.push_back(node);
    }
    nodes = sortedNodes;
}
 
vector<VuoCompilerNode *> VuoCompilerBitcodeGenerator::getNodesToWaitOnBeforeTransmission(VuoCompilerTriggerPort *trigger)
{
    // Does the trigger have a scatter downstream, and another trigger overlaps with some branches of the scatter but
    // not others? If so, then all downstream nodes will be locked before the event can proceed.
    // (The analysis is an approximation. It checks if another trigger overlaps *anywhere* downstream, even if the
    // overlap is after the scatter has been fully gathered back up.)
    // This prevents deadlocks involving one trigger claiming one branch and the other trigger claiming another
    // (https://b33p.net/kosada/node/6696, https://b33p.net/kosada/node/12503).
 
    bool hasScatterOverlappedByAnotherTrigger = graph->hasScatterPartiallyOverlappedByAnotherTrigger(trigger);
 
    // Does the trigger port cause a `Spin Off` node to fire an event that has downstream nodes in common with the trigger?
    // If so, then all downstream nodes will be locked before the event can proceed.
    // This prevents the trigger's event from getting stuck behind and having to wait on the `Spin Off` event,
    // defeating the purpose of the `Spin Off` node (https://b33p.net/kosada/node/11351).
 
    bool hasOverlapWithSpinOff = graph->hasOverlapWithSpinOff(trigger);
 
    // Would the trigger port wait on nodes in a different order than orderedNodes?
    // If so, then all downstream nodes will be locked before the event can proceed.
    // This prevents deadlock where the events from two different trigger ports reach the downstream nodes in a different order
    // (https://b33p.net/kosada/node/7924).
 
    vector<VuoCompilerNode *> sortedDownstreamNodes = downstreamNodesForTrigger[trigger];
    sortNodes(sortedDownstreamNodes);
    bool hasOutOfOrderDownstreamNodes = (downstreamNodesForTrigger[trigger] != sortedDownstreamNodes);
 
    // Wait for either all nodes downstream of the trigger or the nodes directly connected to the trigger.
    vector<VuoCompilerNode *> nodesToWaitOn;
    if (hasScatterOverlappedByAnotherTrigger || hasOverlapWithSpinOff || hasOutOfOrderDownstreamNodes)
        nodesToWaitOn = downstreamNodesForTrigger[trigger];
    else
    {
        nodesToWaitOn = graph->getNodesImmediatelyDownstream(trigger);
        VuoCompilerNode *triggerNode = downstreamNodesForTrigger[trigger].front();
        if (find(nodesToWaitOn.begin(), nodesToWaitOn.end(), triggerNode) == nodesToWaitOn.end())
            nodesToWaitOn.push_back(triggerNode);
    }
 
    return nodesToWaitOn;
}
 
vector<VuoCompilerNode *> VuoCompilerBitcodeGenerator::getNodesToWaitOnBeforeTransmission(VuoCompilerTriggerPort *trigger, VuoCompilerNode *node)
{
    // Does the node have a scatter downstream, and another trigger overlaps with some branches of the scatter but
    // not others? If so, then all downstream nodes will be locked before the event can proceed.
    // (The analysis is an approximation. It checks if another trigger overlaps *anywhere* downstream, even if the
    // overlap is after the scatter has been fully gathered back up.)
    // This prevents deadlocks involving one trigger claiming one branch and the other trigger claiming another
    // (https://b33p.net/kosada/node/6696, https://b33p.net/kosada/node/12503, https://b33p.net/kosada/node/16202).
 
    bool hasGatherOverlappedByAnotherTrigger = graph->hasScatterPartiallyOverlappedByAnotherTrigger(node, trigger);
 
    // Wait for either all nodes downstream of the node or the nodes directly connected to the node.
    vector<VuoCompilerNode *> nodesToWaitOn =
            (hasGatherOverlappedByAnotherTrigger ?
                 graph->getNodesDownstream(node, trigger) :
                 graph->getNodesImmediatelyDownstream(node, trigger));
 
    return nodesToWaitOn;
}
 
void VuoCompilerBitcodeGenerator::makeOrderedTypes(void)
{
    for (VuoCompilerNode *node : graph->getNodes())
    {
        vector<VuoPort *> inputPorts = node->getBase()->getInputPorts();
        vector<VuoPort *> outputPorts = node->getBase()->getOutputPorts();
        vector<VuoPort *> ports;
        ports.insert(ports.end(), inputPorts.begin(), inputPorts.end());
        ports.insert(ports.end(), outputPorts.begin(), outputPorts.end());
 
        for (VuoPort *port : ports)
        {
            VuoType *dataType = static_cast<VuoCompilerPort *>(port->getCompiler())->getDataVuoType();
 
            if (dataType)
            {
                vector<VuoCompilerType *>::iterator typeIter = find(orderedTypes.begin(), orderedTypes.end(), dataType->getCompiler());
                if (typeIter == orderedTypes.end())
                    orderedTypes.push_back(dataType->getCompiler());
            }
        }
    }
}
 
void VuoCompilerBitcodeGenerator::makePortContextInfo(void)
{
    for (VuoCompilerNode *node : graph->getNodes())
    {
        vector<VuoPort *> inputPorts = node->getBase()->getInputPorts();
        vector<VuoPort *> outputPorts = node->getBase()->getOutputPorts();
        vector<VuoPort *> ports;
        ports.insert(ports.end(), inputPorts.begin(), inputPorts.end());
        ports.insert(ports.end(), outputPorts.begin(), outputPorts.end());
        for (size_t i = 0; i < ports.size(); ++i)
        {
            VuoCompilerPort *port = static_cast<VuoCompilerPort *>( ports[i]->getCompiler() );
 
            port->setNodeIdentifier( node->getIdentifier() );
            port->setIndexInPortContexts(i);
        }
    }
}
 
void VuoCompilerBitcodeGenerator::makeSubcompositionModelPorts(void)
{
    Module module("", *VuoCompiler::globalLLVMContext);
 
    vector<VuoPublishedPort *> publishedInputPorts = composition->getBase()->getPublishedInputPorts();
    vector<VuoPublishedPort *> publishedOutputPorts = composition->getBase()->getPublishedOutputPorts();
    modelInputPorts.insert( modelInputPorts.end(), publishedInputPorts.begin(), publishedInputPorts.end() );
    modelOutputPorts.insert( modelOutputPorts.end(), publishedOutputPorts.begin(), publishedOutputPorts.end() );
 
    set<string> publishedOutputTriggerNames = graph->getPublishedOutputTriggers();
 
    for (size_t i = 0; i < modelOutputPorts.size(); ++i)
    {
        string portName = modelOutputPorts[i]->getClass()->getName();
        if (publishedOutputTriggerNames.find(portName) != publishedOutputTriggerNames.end())
        {
            VuoType *dataType = static_cast<VuoCompilerPortClass *>( modelOutputPorts[i]->getClass()->getCompiler() )->getDataVuoType();
            VuoCompilerTriggerPortClass *modelTriggerPortClass = new VuoCompilerTriggerPortClass(portName);
            modelTriggerPortClass->setDataVuoType(dataType);
            VuoCompilerPort *modelTriggerPort = modelTriggerPortClass->newPort();
            modelOutputPorts[i] = modelTriggerPort->getBase();
        }
    }
}
 
void VuoCompilerBitcodeGenerator::makeDependencies(void)
{
    // Make sure all loading of dependencies for makeDependencies_Pro() happens before we get on llvmQueue.
    dependencies = compiler->getDirectDependenciesForComposition(composition);
 
#if VUO_PRO
    makeDependencies_Pro();
#endif
 
    // Make sure all subcompositions needed by generateTriggerFunctions() are loaded before we get on llvmQueue.
    compiler->getDependenciesForComposition(composition);
}
 
Module * VuoCompilerBitcodeGenerator::generateBitcode(void)
{
    bool isStatefulComposition = false;
    for (VuoCompilerNode *node : graph->getNodes())
    {
        if (node->getBase()->getNodeClass()->getCompiler()->isStateful())
        {
            isStatefulComposition = true;
            break;
        }
    }
 
    module = new Module(moduleKey, *VuoCompiler::globalLLVMContext);
    constantsCache = new VuoCompilerConstantsCache(module);
 
    for (VuoCompilerNode *node : orderedNodes)
        node->setConstantsCache(constantsCache);
 
    generateCompositionMetadata();
 
    generateTriggerFunctions();
 
    if (! isTopLevelComposition)
        generateNodeEventFunction(isStatefulComposition);
 
    if (isStatefulComposition)
    {
        generateNodeInstanceInitFunction();
        generateNodeInstanceFiniFunction();
        generateNodeInstanceTriggerStartFunction();
        if (! isTopLevelComposition)
            generateNodeInstanceTriggerUpdateFunction();
    }
 
    generateNodeInstanceTriggerStopFunction();
 
    generateCompositionReleasePortDataFunction();
 
    generateCompositionGetPortValueFunction();
    generateCompositionSetPortValueFunction();
    generateCompositionFireTriggerPortEventFunction();
 
    generateCompositionSetPublishedInputPortValueFunction();
 
    generateCompositionCreateContextForNodeFunction();
    generateCompositionAddNodeMetadataFunction();
    generateCompositionPerformDataOnlyTransmissionsFunction();
 
    if (isTopLevelComposition)
    {
        generateShouldShowSplashWindowFunction(compiler->shouldShowSplashWindow());
 
        generateAllocation();
        generateSetupFunction(isStatefulComposition);
        generateCleanupFunction();
 
        generateInstanceInitFunction(isStatefulComposition);
        generateInstanceFiniFunction(isStatefulComposition);
        generateInstanceTriggerStartFunction(isStatefulComposition);
        generateInstanceTriggerStopFunction(isStatefulComposition);
 
        generateSetInputPortValueFunction();
 
        generateGetPublishedPortCountFunction(true);
        generateGetPublishedPortCountFunction(false);
        generateGetPublishedPortNamesFunction(true);
        generateGetPublishedPortNamesFunction(false);
        generateGetPublishedPortTypesFunction(true);
        generateGetPublishedPortTypesFunction(false);
        generateGetPublishedPortDetailsFunction(true);
        generateGetPublishedPortDetailsFunction(false);
        generateGetPublishedPortValueFunction(true);
        generateGetPublishedPortValueFunction(false);
        generateSetPublishedInputPortValueFunction();
        generateFirePublishedInputPortEventFunction();
    }
 
    composition->setModule(module);
 
    delete constantsCache;
    constantsCache = nullptr;
 
    return module;
}
 
void VuoCompilerBitcodeGenerator::generateCompositionMetadata(void)
{
    json_object *metadataJson = json_object_new_object();
    json_object *nodeMetadataJson = json_object_new_object();
 
    string title = composition->getBase()->getMetadata()->getCustomizedName();
    if (title.empty())
    {
        string nodeClassNamePart = VuoStringUtilities::split(moduleKey, '.').back();
        title = VuoStringUtilities::expandCamelCase(nodeClassNamePart);
    }
    json_object_object_add(metadataJson, "title", json_object_new_string(title.c_str()));
 
    string description = composition->getBase()->getMetadata()->getDescription();
    json_object_object_add(metadataJson, "description", json_object_new_string(description.c_str()));
 
    json_object *keywordsJson = json_object_new_array();
    for (const string &keyword : composition->getBase()->getMetadata()->getKeywords())
        json_object_array_add(keywordsJson, json_object_new_string(keyword.c_str()));
    json_object_object_add(metadataJson, "keywords", keywordsJson);
 
    string version = composition->getBase()->getMetadata()->getVersion();
    if (! version.empty())
        json_object_object_add(metadataJson, "version", json_object_new_string(version.c_str()));
 
    json_object *dependenciesJson = json_object_new_array();
    for (const string &dependency : dependencies)
        json_object_array_add(dependenciesJson, json_object_new_string(dependency.c_str()));
    json_object_object_add(metadataJson, "dependencies", dependenciesJson);
 
    json_object *compatibilityJson = json_tokener_parse(composition->getCompatibleTargets().toJsonString().c_str());
    json_object_object_add(metadataJson, "compatibility", compatibilityJson);
 
    if (! isTopLevelComposition)
    {
#if VUO_PRO
        generateCompositionMetadata_Pro(nodeMetadataJson);
#endif
 
        json_object *triggersJson = json_object_new_array();
        for (VuoCompilerTriggerPort *trigger : graph->getTriggerPorts())
        {
            VuoCompilerNode *triggerNode = graph->getNodeForTriggerPort(trigger);
            json_object *t = VuoCompilerTriggerDescription::getJson(triggerNode, trigger, graph);
            json_object_array_add(triggersJson, t);
        }
        for (VuoCompilerNode *node : graph->getNodes())
        {
            VuoCompilerNodeClass *nodeClass = node->getBase()->getNodeClass()->getCompiler();
            vector<VuoCompilerTriggerDescription *> triggersInSubcomposition = nodeClass->getTriggerDescriptions();
            for (VuoCompilerTriggerDescription *triggerInSubcomposition : triggersInSubcomposition)
            {
                json_object *t = triggerInSubcomposition->getJsonWithinSubcomposition(node);
                json_object_array_add(triggersJson, t);
            }
        }
        json_object_object_add(nodeMetadataJson, "triggers", triggersJson);
 
        json_object *nodesJson = json_object_new_object();
        for (VuoCompilerNode *node : orderedNodes)
        {
            json_object *nodeClassNameJson = json_object_new_string(node->getBase()->getNodeClass()->getClassName().c_str());
            json_object_object_add(nodesJson, node->getIdentifier().c_str(), nodeClassNameJson);
        }
        json_object_object_add(nodeMetadataJson, "nodes", nodesJson);
    }
 
    json_object_object_add(metadataJson, "node", nodeMetadataJson);
 
    string metadata = json_object_to_json_string_ext(metadataJson, JSON_C_TO_STRING_PLAIN);
    json_object_put(metadataJson);
 
    VuoCompilerCodeGenUtilities::generateModuleMetadata(module, metadata, moduleKey);
}
 
void VuoCompilerBitcodeGenerator::generateShouldShowSplashWindowFunction(bool shouldShow)
{
    IntegerType *returnType = IntegerType::get(module->getContext(), 8);
    FunctionType *functionType = FunctionType::get(returnType, false);
    Function *function = Function::Create(functionType, GlobalValue::ExternalLinkage, "vuoShouldShowSplashWindow", module);
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
    Value *boolValue = ConstantInt::get(returnType, shouldShow);
    ReturnInst::Create(module->getContext(), boolValue, block);
}
 
void VuoCompilerBitcodeGenerator::generateCompositionAddNodeMetadataFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getCompositionAddNodeMetadataFunction(module);
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
 
    Function::arg_iterator args = function->arg_begin();
    Value *compositionStateValue = args++;
    compositionStateValue->setName("compositionState");
 
    Function *compositionCreateContextForNodeFunction = VuoCompilerCodeGenUtilities::getCompositionCreateContextForNodeFunction(module);
    Function *compositionSetPortValueFunction = VuoCompilerCodeGenUtilities::getCompositionSetPortValueFunction(module);
    Function *compositionGetPortValueFunction = VuoCompilerCodeGenUtilities::getCompositionGetPortValueFunction(module);
    Function *compositionFireTriggerPortEventFunction = VuoCompilerCodeGenUtilities::getCompositionFireTriggerPortEventFunction(module);
    Function *releasePortDataFunction = VuoCompilerCodeGenUtilities::getCompositionReleasePortDataFunction(module);
 
    for (vector<VuoCompilerNode *>::iterator i = orderedNodes.begin(); i != orderedNodes.end(); ++i)
    {
        VuoCompilerNode *node = *i;
 
        node->generateAddMetadata(module, block, compositionStateValue, orderedTypes, compositionCreateContextForNodeFunction,
                                  compositionSetPortValueFunction, compositionGetPortValueFunction, compositionFireTriggerPortEventFunction,
                                  releasePortDataFunction);
    }
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateCompositionCreateContextForNodeFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getCompositionCreateContextForNodeFunction(module);
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, NULL);
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, NULL);
 
    Function::arg_iterator args = function->arg_begin();
    Value *nodeIndexValue = args++;
    nodeIndexValue->setName("nodeIndex");
 
    PointerType *pointerToNodeContext = PointerType::get(VuoCompilerCodeGenUtilities::getNodeContextType(module), 0);
    AllocaInst *nodeContextVariable = new AllocaInst(pointerToNodeContext, 0, "nodeContext", initialBlock);
 
    vector< pair<BasicBlock *, BasicBlock *> > blocksForIndex;
 
    for (size_t i = 0; i < orderedNodes.size(); ++i)
    {
        VuoCompilerNode *node = orderedNodes[i];
 
        BasicBlock *block = BasicBlock::Create(module->getContext(), node->getIdentifier(), function, NULL);
        Value *nodeContextValue = node->generateCreateContext(module, block);
        new StoreInst(nodeContextValue, nodeContextVariable, block);
 
        blocksForIndex.push_back(make_pair(block, block));
    }
 
    VuoCompilerCodeGenUtilities::generateIndexMatchingCode(module, function, initialBlock, finalBlock, nodeIndexValue, blocksForIndex);
 
    Value *nodeContextValue = new LoadInst(nodeContextVariable, "", false, finalBlock);
    ReturnInst::Create(module->getContext(), nodeContextValue, finalBlock);
}
 
void VuoCompilerBitcodeGenerator::generateCompositionPerformDataOnlyTransmissionsFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getCompositionPerformDataOnlyTransmissionsFunction(module);
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
 
    Function::arg_iterator args = function->arg_begin();
    Value *compositionStateValue = args++;
    compositionStateValue->setName("compositionState");
 
    // Copy data along cables supporting data-only transmission at this level of the composition.
 
    for (VuoCompilerNode *node : graph->getSourceNodesOfDataOnlyTransmission())
        generateDataOnlyTransmissionFromNode(function, block, compositionStateValue, node, false, false, false);
 
    // For each subcomposition node…
 
    for (VuoCompilerNode *node : orderedNodes)
    {
        Function *subcompositionFunctionSrc = node->getBase()->getNodeClass()->getCompiler()->getCompositionPerformDataOnlyTransmissionsFunction();
        if (subcompositionFunctionSrc)
        {
            Value *runtimeStateValue = VuoCompilerCodeGenUtilities::generateGetCompositionStateRuntimeState(module, block, compositionStateValue);
            Value *compositionIdentifierValue = VuoCompilerCodeGenUtilities::generateGetCompositionStateCompositionIdentifier(module, block, compositionStateValue);
            Value *subcompositionIdentifierValue = node->generateSubcompositionIdentifierValue(module, block, compositionIdentifierValue);
            Value *subcompositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, runtimeStateValue, subcompositionIdentifierValue);
            Value *subcompositionStateValueDst = new BitCastInst(subcompositionStateValue, subcompositionFunctionSrc->getFunctionType()->getParamType(0), "", block);
 
            // Copy the subcomposition node's input port values to the subcomposition's published input node's input ports.
 
            Function *setPublishedInputPortValueFunctionSrc = node->getBase()->getNodeClass()->getCompiler()->getCompositionSetPublishedInputPortValueFunction();
            Function *setPublishedInputPortValueFunctionDst = VuoCompilerModule::declareFunctionInModule(module, setPublishedInputPortValueFunctionSrc);
            Value *falseValue = ConstantInt::get(setPublishedInputPortValueFunctionDst->getFunctionType()->getParamType(3), 0);
 
            for (VuoPort *inputPort : node->getBase()->getInputPorts())
            {
                VuoCompilerInputEventPort *inputEventPort = static_cast<VuoCompilerInputEventPort *>(inputPort->getCompiler());
                VuoCompilerInputData *inputData = inputEventPort->getData();
                if (inputData)
                {
                    Value *inputPortNameValue = constantsCache->get(inputPort->getClass()->getName());
                    Value *dataValue = constantsCache->get(inputData->getInitialValue());
 
                    vector<Value *> args;
                    args.push_back(subcompositionStateValueDst);
                    args.push_back(inputPortNameValue);
                    args.push_back(dataValue);
                    args.push_back(falseValue);
                    CallInst::Create(setPublishedInputPortValueFunctionDst, args, "", block);
                }
            }
 
            // Call recursively for the subcomposition.
 
            Function *subcompositionFunctionDst = VuoCompilerModule::declareFunctionInModule(module, subcompositionFunctionSrc);
            CallInst::Create(subcompositionFunctionDst, subcompositionStateValueDst, "", block);
 
            VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, subcompositionStateValue);
            VuoCompilerCodeGenUtilities::generateFreeCall(module, block, subcompositionIdentifierValue);
        }
    }
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateCompositionReleasePortDataFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getCompositionReleasePortDataFunction(module);
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, NULL);
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, NULL);
 
    Function::arg_iterator args = function->arg_begin();
    Value *portAddressAsVoidPointer = args++;
    portAddressAsVoidPointer->setName("portData");
    Value *typeIndexValue = args++;
    typeIndexValue->setName("typeIndex");
 
    vector< pair<BasicBlock *, BasicBlock *> > blocksForIndex;
 
    for (vector<VuoCompilerType *>::iterator i = orderedTypes.begin(); i != orderedTypes.end(); ++i)
    {
        VuoCompilerType *type = *i;
 
        BasicBlock *block = BasicBlock::Create(module->getContext(), type->getBase()->getModuleKey(), function, NULL);
        type->generateReleaseCall(module, block, portAddressAsVoidPointer);
 
        blocksForIndex.push_back(make_pair(block, block));
    }
 
    VuoCompilerCodeGenUtilities::generateIndexMatchingCode(module, function, initialBlock, finalBlock, typeIndexValue, blocksForIndex);
 
    ReturnInst::Create(module->getContext(), finalBlock);
}
 
void VuoCompilerBitcodeGenerator::generateSetInputDataFromNodeFunctionArguments(Function *function, BasicBlock *&block, Value *compositionStateValue,
                                                                                map<VuoPort *, size_t> indexOfParameter,
                                                                                map<VuoPort *, size_t> indexOfEventParameter,
                                                                                bool shouldWaitForDataOnlyDownstreamNodes,
                                                                                bool shouldUpdateTriggers, bool shouldSendTelemetry)
{
    VuoCompilerNode *publishedInputNode = graph->getPublishedInputNode();
    if (! publishedInputNode)
        return;
 
    Value *publishedNodeContextValue = publishedInputNode->generateGetContext(module, block, compositionStateValue);
 
    vector<VuoPublishedPort *> publishedInputPorts = composition->getBase()->getPublishedInputPorts();
    vector<VuoCompilerInputEventPort *> inputEventPorts;
 
    // Copy data from the function arguments to the published input node's input ports.
 
    for (size_t i = 0; i < publishedInputPorts.size(); ++i)
    {
        VuoPublishedPort *publishedInputPort = publishedInputPorts[i];
 
        VuoPort *inputPort = graph->getInputPortOnPublishedInputNode(i);
        VuoCompilerInputEventPort *inputEventPort = static_cast<VuoCompilerInputEventPort *>( inputPort->getCompiler() );
        inputEventPorts.push_back(inputEventPort);
 
        if (publishedInputPort->getClass()->getPortType() == VuoPortClass::dataAndEventPort)
        {
            size_t dataArgIndex = indexOfParameter[ modelInputPorts[i] ];
            Value *dataPointer = inputEventPort->getDataType()->convertArgsToPortData(module, block, function, dataArgIndex);
 
            inputEventPort->generateReplaceData(module, block, publishedNodeContextValue, dataPointer);
        }
    }
 
    // Transmit data through the published input node and onward through the published input cables.
    // (This temporarily sets an event on all of the published input node's input ports.)
 
    generateDataOnlyTransmissionFromNode(function, block, compositionStateValue, publishedInputNode,
                                         shouldWaitForDataOnlyDownstreamNodes, shouldUpdateTriggers, shouldSendTelemetry);
 
    // Copy events from the function arguments to the published input node's input ports.
 
    for (size_t i = 0; i < publishedInputPorts.size(); ++i)
    {
        VuoCompilerInputEventPort *inputEventPort = inputEventPorts[i];
 
        map<VuoPort *, size_t> *indexMap = (inputEventPort->getBase()->getClass()->getPortType() == VuoPortClass::dataAndEventPort ?
                                                &indexOfEventParameter :
                                                &indexOfParameter);
 
        auto foundIndex = indexMap->find( modelInputPorts[i] );
        if (foundIndex != indexMap->end())
        {
            size_t eventArgIndex = foundIndex->second;
            Value *eventArg = VuoCompilerCodeGenUtilities::getArgumentAtIndex(function, eventArgIndex);
 
            inputEventPort->generateStoreEvent(module, block, publishedNodeContextValue, eventArg);
        }
    }
}
 
void VuoCompilerBitcodeGenerator::generateNodeEventFunction(bool isStatefulComposition)
{
    vector<VuoPort *> modelPorts;
    modelPorts.insert(modelPorts.end(), modelInputPorts.begin(), modelInputPorts.end());
    modelPorts.insert(modelPorts.end(), modelOutputPorts.begin(), modelOutputPorts.end());
 
    vector<VuoPublishedPort *> publishedInputPorts = composition->getBase()->getPublishedInputPorts();
    vector<VuoPublishedPort *> publishedOutputPorts = composition->getBase()->getPublishedOutputPorts();
    vector<VuoPublishedPort *> publishedPorts;
    publishedPorts.insert(publishedPorts.end(), publishedInputPorts.begin(), publishedInputPorts.end());
    publishedPorts.insert(publishedPorts.end(), publishedOutputPorts.begin(), publishedOutputPorts.end());
 
    map<VuoPort *, string> displayNamesForPorts;
    map<VuoPort *, json_object *> detailsForPorts;
    for (size_t i = 0; i < modelPorts.size(); ++i)
    {
        VuoPort *modelPort = modelPorts[i];
        VuoPublishedPort *publishedPort = publishedPorts[i];
 
        string portName = modelPort->getClass()->getName();
        bool isAllCaps = true;
        for (size_t j = 0; j < portName.length(); ++j)
            if (! isupper(portName[j]))
            {
                isAllCaps = false;
                break;
            }
        if (isAllCaps)
            displayNamesForPorts[modelPort] = portName;
 
        detailsForPorts[modelPort] = static_cast<VuoCompilerPortClass *>( publishedPort->getClass()->getCompiler() )->getDetails();
    }
 
    map<VuoPort *, string> defaultValuesForInputPorts;
    map<VuoPort *, VuoPortClass::EventBlocking> eventBlockingForInputPorts;
    for (size_t i = 0; i < publishedInputPorts.size(); ++i)
    {
        VuoPublishedPort *publishedInputPort = publishedInputPorts[i];
 
        string defaultValue = static_cast<VuoCompilerPublishedPort *>( publishedInputPort->getCompiler() )->getInitialValue();
        if (! defaultValue.empty())
            defaultValuesForInputPorts[publishedInputPort] = defaultValue;
 
        eventBlockingForInputPorts[publishedInputPort] = graph->getPublishedInputEventBlocking(i);
    }
 
    map<VuoPort *, size_t> indexOfParameter;
    map<VuoPort *, size_t> indexOfEventParameter;
    Function *function = VuoCompilerCodeGenUtilities::getNodeEventFunction(module, moduleKey, true, isStatefulComposition,
                                                                           VuoCompilerCodeGenUtilities::getCompositionInstanceDataType(module),
                                                                           modelInputPorts, modelOutputPorts,
                                                                           detailsForPorts, displayNamesForPorts,
                                                                           defaultValuesForInputPorts, eventBlockingForInputPorts,
                                                                           indexOfParameter, indexOfEventParameter, constantsCache);
    BasicBlock *block = &(function->getEntryBlock());
 
    VuoCompilerTriggerPort *trigger = graph->getPublishedInputTrigger();
    if (! trigger)
    {
        ReturnInst::Create(module->getContext(), block);
        return;
    }
 
    VuoCompilerNode *triggerNode = graph->getNodeForTriggerPort(trigger);
 
    Value *compositionStateValue = function->arg_begin();
    Value *compositionContextValue = VuoCompilerCodeGenUtilities::generateGetCompositionContext(module, block, compositionStateValue);
 
    // Get the event ID passed down from the composition containing this subcomposition node.
 
    Value *eventIdValue = VuoCompilerCodeGenUtilities::generateGetOneExecutingEvent(module, block, compositionContextValue);
 
    // Claim all necessary downstream nodes.
 
    vector<VuoCompilerNode *> triggerWaitNodes = getNodesToWaitOnBeforeTransmission(trigger);
    generateLockNodes(module, block, compositionStateValue, triggerWaitNodes, eventIdValue);
 
    // Set the data and event for each input port on the published input node from the input arguments.
 
    bool hasClaimedNodesDownstreamOfPublishedInputNode = (triggerWaitNodes.size() > 2);
    generateSetInputDataFromNodeFunctionArguments(function, block, compositionStateValue, indexOfParameter, indexOfEventParameter,
                                                  ! hasClaimedNodesDownstreamOfPublishedInputNode, true, true);
 
    // Wait for the event to reach the published output node (if any) and all other leaf nodes — part 1.
 
    Value *subcompositionOutputGroupValue = VuoCompilerCodeGenUtilities::generateGetNodeContextExecutingGroup(module, block, compositionContextValue);
    VuoCompilerCodeGenUtilities::generateEnterDispatchGroup(module, block, subcompositionOutputGroupValue);
 
    // Fire an event from the published input trigger.
 
    Value *triggerNodeContextValue = triggerNode->generateGetContext(module, block, compositionStateValue);
    Value *triggerFunctionValue = trigger->generateLoadFunction(module, block, triggerNodeContextValue);
    CallInst::Create(triggerFunctionValue, "", block);
 
    // Wait for the event to reach the published output node (if any) and all other leaf nodes — part 2.
 
    VuoCompilerCodeGenUtilities::generateWaitForDispatchGroup(module, block, subcompositionOutputGroupValue);
 
    // Set each output argument from the published output port values.
 
    VuoCompilerNode *publishedOutputNode = graph->getPublishedOutputNode();
    Value *publishedOutputNodeContext = publishedOutputNode->generateGetContext(module, block, compositionStateValue);
    for (size_t i = 0; i < modelOutputPorts.size(); ++i)
    {
        VuoPort *modelOutputPort = modelOutputPorts[i];
        VuoPortClass::PortType portType = modelOutputPort->getClass()->getPortType();
 
        if (portType == VuoPortClass::dataAndEventPort || portType == VuoPortClass::eventOnlyPort)
        {
            VuoCompilerEventPort *inputPort = static_cast<VuoCompilerEventPort *>( graph->getInputPortOnPublishedOutputNode(i)->getCompiler() );
            bool hasEventParameter = false;
            size_t eventIndex = 0;
 
            if (portType == VuoPortClass::dataAndEventPort)
            {
                size_t index = indexOfParameter[ modelOutputPort ];
                Value *outputArg = VuoCompilerCodeGenUtilities::getArgumentAtIndex(function, index);
 
                Value *inputDataPointer = inputPort->generateRetrieveData(module, block, publishedOutputNodeContext);
 
                VuoCompilerType *dataType = inputPort->getDataVuoType()->getCompiler();
                VuoCompilerCodeGenUtilities::generateMemoryCopy(module, block, inputDataPointer, outputArg, dataType);
 
                map<VuoPort *, size_t>::iterator iter = indexOfEventParameter.find(modelOutputPort);
                if (iter != indexOfEventParameter.end())
                {
                    hasEventParameter = true;
                    eventIndex = iter->second;
                }
            }
            else
            {
                hasEventParameter = true;
                eventIndex = indexOfParameter[ modelOutputPort ];
            }
 
            if (hasEventParameter)
            {
                Value *outputArg = VuoCompilerCodeGenUtilities::getArgumentAtIndex(function, eventIndex);
 
                Value *eventValue = VuoCompilerCodeGenUtilities::generateGetNodeContextOutputEvent(module, block, compositionContextValue, i);
                new StoreInst(eventValue, outputArg, block);
            }
        }
    }
 
    // Signal the published output node.
 
    generateUnlockNodes(module, block, compositionStateValue, vector<VuoCompilerNode *>(1, publishedOutputNode));
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateNodeInstanceInitFunction(void)
{
    vector<VuoPort *> inputPorts;
    if (! isTopLevelComposition)
        inputPorts = modelInputPorts;
 
    map<VuoPort *, size_t> indexOfParameter;
    Function *function = VuoCompilerCodeGenUtilities::getNodeInstanceInitFunction(module, moduleKey, true,
                                                                                  VuoCompilerCodeGenUtilities::getCompositionInstanceDataType(module),
                                                                                  inputPorts, indexOfParameter, constantsCache);
    BasicBlock *block = &(function->getEntryBlock());
 
    Value *compositionStateValue = function->arg_begin();
 
    if (! isTopLevelComposition)
        generateSetInputDataFromNodeFunctionArguments(function, block, compositionStateValue, indexOfParameter, map<VuoPort *, size_t>(),
                                                      false, false, false);
 
    for (VuoCompilerNode *node : graph->getNodes())
    {
        if (node->getBase()->getNodeClass()->getCompiler()->isStateful())
        {
            BasicBlock *initBlock = NULL;
            BasicBlock *nextBlock = NULL;
            Value *replacementJsonValue = NULL;
            VuoCompilerCodeGenUtilities::generateIsNodeBeingAddedOrReplacedCheck(module, function, node->getIdentifier(),
                                                                                 compositionStateValue, block, initBlock, nextBlock,
                                                                                 constantsCache, replacementJsonValue);
 
            node->generateInitFunctionCall(module, initBlock, compositionStateValue);
 
            VuoCompilerCodeGenUtilities::generateJsonObjectPut(module, initBlock, replacementJsonValue);
 
            BranchInst::Create(nextBlock, initBlock);
            block = nextBlock;
        }
    }
 
    PointerType *instanceDataType = static_cast<PointerType *>( function->getReturnType() );
    ConstantPointerNull *nullInstanceDataValue = ConstantPointerNull::get(instanceDataType);
    ReturnInst::Create(module->getContext(), nullInstanceDataValue, block);
}
 
void VuoCompilerBitcodeGenerator::generateNodeInstanceFiniFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getNodeInstanceFiniFunction(module, moduleKey,
                                                                                  VuoCompilerCodeGenUtilities::getCompositionInstanceDataType(module),
                                                                                  constantsCache);
    BasicBlock *block = &(function->getEntryBlock());
 
    Value *compositionStateValue = function->arg_begin();
 
    for (VuoCompilerNode *node : graph->getNodes())
    {
        if (node->getBase()->getNodeClass()->getCompiler()->isStateful())
        {
            BasicBlock *finiBlock = NULL;
            BasicBlock *nextBlock = NULL;
            Value *replacementJsonValue = NULL;
            VuoCompilerCodeGenUtilities::generateIsNodeBeingRemovedOrReplacedCheck(module, function, node->getIdentifier(),
                                                                                   compositionStateValue, block, finiBlock, nextBlock,
                                                                                   constantsCache, replacementJsonValue);
 
            node->generateFiniFunctionCall(module, finiBlock, compositionStateValue);
 
            VuoCompilerCodeGenUtilities::generateJsonObjectPut(module, finiBlock, replacementJsonValue);
 
            BranchInst::Create(nextBlock, finiBlock);
            block = nextBlock;
        }
    }
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateNodeInstanceTriggerStartFunction(void)
{
    vector<VuoPort *> inputPorts;
    if (! isTopLevelComposition)
        inputPorts = modelInputPorts;
 
    map<VuoPort *, size_t> indexOfParameter;
    Function *function = VuoCompilerCodeGenUtilities::getNodeInstanceTriggerStartFunction(module, moduleKey,
                                                                                          VuoCompilerCodeGenUtilities::getCompositionInstanceDataType(module),
                                                                                          inputPorts, indexOfParameter, constantsCache);
    BasicBlock *block = &(function->getEntryBlock());
 
    Value *compositionStateValue = function->arg_begin();
 
    if (! isTopLevelComposition)
        generateSetInputDataFromNodeFunctionArguments(function, block, compositionStateValue, indexOfParameter, map<VuoPort *, size_t>(),
                                                      false, false, false);
 
    // Since a node's nodeInstanceTriggerStart() function can generate an event,
    // make sure trigger functions wait until all nodes' init functions have completed.
    generateLockNodes(module, block, compositionStateValue, orderedNodes);
 
    for (VuoCompilerNode *node : graph->getNodes())
    {
        if (node->getBase()->getNodeClass()->getCompiler()->isStateful())
        {
            // { /* call nodeInstanceTriggerStart() for node */ }
            node->generateCallbackStartFunctionCall(module, block, compositionStateValue);
        }
    }
 
    generateUnlockNodes(module, block, compositionStateValue, orderedNodes);
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateNodeInstanceTriggerStopFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getNodeInstanceTriggerStopFunction(module, moduleKey,
                                                                                         VuoCompilerCodeGenUtilities::getCompositionInstanceDataType(module),
                                                                                         constantsCache);
    BasicBlock *block = &(function->getEntryBlock());
 
    Value *compositionStateValue = function->arg_begin();
 
    // Stop all triggers from firing events — call nodeInstanceTriggerStop() for each stateful node.
    generateLockNodes(module, block, compositionStateValue, orderedNodes);
    for (VuoCompilerNode *node : graph->getNodes())
    {
        if (node->getBase()->getNodeClass()->getCompiler()->isStateful())
            node->generateCallbackStopFunctionCall(module, block, compositionStateValue);
    }
    generateUnlockNodes(module, block, compositionStateValue, orderedNodes);
 
    if (isTopLevelComposition)
    {
        // Wait for any scheduled trigger workers to launch events into the composition.
        Value *triggerWorkersScheduledValue = VuoCompilerCodeGenUtilities::getTriggerWorkersScheduledValue(module, block, compositionStateValue);
        VuoCompilerCodeGenUtilities::generateWaitForDispatchGroup(module, block, triggerWorkersScheduledValue);
 
        // Wait for any in-progress events to travel through the composition.
        generateLockNodes(module, block, compositionStateValue, orderedNodes);
        generateUnlockNodes(module, block, compositionStateValue, orderedNodes);
    }
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateNodeInstanceTriggerUpdateFunction(void)
{
    map<VuoPort *, size_t> indexOfParameter;
    Function *function = VuoCompilerCodeGenUtilities::getNodeInstanceTriggerUpdateFunction(module, moduleKey,
                                                                                           VuoCompilerCodeGenUtilities::getCompositionInstanceDataType(module),
                                                                                           modelInputPorts, indexOfParameter, constantsCache);
    BasicBlock *block = &(function->getEntryBlock());
 
    Value *compositionStateValue = function->arg_begin();
 
    VuoCompilerTriggerPort *trigger = graph->getPublishedInputTrigger();
    if (! trigger)
    {
        ReturnInst::Create(module->getContext(), block);
        return;
    }
 
    vector<VuoCompilerNode *> triggerWaitNodes = getNodesToWaitOnBeforeTransmission(trigger);
    generateLockNodes(module, block, compositionStateValue, triggerWaitNodes);
 
    bool hasClaimedNodesDownstreamOfPublishedInputNode = (triggerWaitNodes.size() > 2);
    generateSetInputDataFromNodeFunctionArguments(function, block, compositionStateValue, indexOfParameter, map<VuoPort *, size_t>(),
                                                  ! hasClaimedNodesDownstreamOfPublishedInputNode, true, true);
 
    generateUnlockNodes(module, block, compositionStateValue, triggerWaitNodes);
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateLockNodes(Module *module, BasicBlock *block,
                                                       Value *compositionStateValue, vector<VuoCompilerNode *> nodes,
                                                       Value *eventIdValue)
{
    if (nodes.empty())
        return;
 
    if (! eventIdValue)
        eventIdValue = VuoCompilerCodeGenUtilities::generateGetNextEventId(module, block, compositionStateValue);
 
    if (nodes.size() == 1)
    {
        size_t nodeIndex = nodes[0]->getIndexInOrderedNodes();
        VuoCompilerCodeGenUtilities::generateLockNode(module, block, compositionStateValue, nodeIndex, eventIdValue);
    }
    else
    {
        sortNodes(nodes);
 
        vector<size_t> nodeIndices;
        std::transform(nodes.begin(), nodes.end(), std::back_inserter(nodeIndices), [](VuoCompilerNode *n) { return n->getIndexInOrderedNodes(); });
 
        VuoCompilerCodeGenUtilities::generateLockNodes(module, block, compositionStateValue, nodeIndices, eventIdValue, constantsCache);
    }
}
 
void VuoCompilerBitcodeGenerator::generateUnlockNodes(Module *module, BasicBlock *block, Value *compositionStateValue,
                                                      vector<VuoCompilerNode *> nodes)
{
    if (nodes.empty())
        return;
 
    if (nodes.size() == 1)
    {
        size_t nodeIndex = nodes[0]->getIndexInOrderedNodes();
        VuoCompilerCodeGenUtilities::generateUnlockNode(module, block, compositionStateValue, nodeIndex);
    }
    else
    {
        vector<size_t> nodeIndices;
        std::transform(nodes.begin(), nodes.end(), std::back_inserter(nodeIndices), [](VuoCompilerNode *n) { return n->getIndexInOrderedNodes(); });
 
        VuoCompilerCodeGenUtilities::generateUnlockNodes(module, block, compositionStateValue, nodeIndices, constantsCache);
    }
}
 
void VuoCompilerBitcodeGenerator::generateCompositionGetPortValueFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getCompositionGetPortValueFunction(module);
 
    Function::arg_iterator args = function->arg_begin();
    Value *compositionStateValue = args++;
    compositionStateValue->setName("compositionState");
    Value *portIdentifierValue = args++;
    portIdentifierValue->setName("portIdentifier");
    Value *serializationTypeValue = args++;
    serializationTypeValue->setName("serializationType");
    Value *isThreadSafeValue = args++;
    isThreadSafeValue->setName("isThreadSafe");
 
 
    // char *ret = NULL;
 
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, 0);
    PointerType *pointerToCharType = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
 
    AllocaInst *retVariable = new AllocaInst(pointerToCharType, 0, "ret", initialBlock);
    ConstantPointerNull *nullPointerToChar = ConstantPointerNull::get(pointerToCharType);
    new StoreInst(nullPointerToChar, retVariable, false, initialBlock);
 
    // void *portAddress = vuoGetDataForPort(compositionState, portIdentifier);
 
    Value *portAddressAsVoidPointer = VuoCompilerCodeGenUtilities::generateGetDataForPort(module, initialBlock, compositionStateValue, portIdentifierValue);
 
    // if (portAddress != NULL)
 
    BasicBlock *checkWaitBlock = BasicBlock::Create(module->getContext(), "checkWait", function, 0);
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, 0);
 
    ConstantPointerNull *nullPortAddress = ConstantPointerNull::get(static_cast<PointerType *>(portAddressAsVoidPointer->getType()));
    ICmpInst *portAddressNotEqualsNull = new ICmpInst(*initialBlock, ICmpInst::ICMP_NE, portAddressAsVoidPointer, nullPortAddress, "");
    BranchInst::Create(checkWaitBlock, finalBlock, portAddressNotEqualsNull, initialBlock);
 
    // unsigned long typeIndex = vuoGetTypeIndexForPort(compositionState, portIdentifier);
    // unsigned long nodeIndex = vuoGetNodeIndexForPort(compositionState, portIdentifier);
 
    Value *typeIndexValue = VuoCompilerCodeGenUtilities::generateGetTypeIndexForPort(module, checkWaitBlock, compositionStateValue, portIdentifierValue);
    Value *nodeIndexValue = VuoCompilerCodeGenUtilities::generateGetNodeIndexForPort(module, checkWaitBlock, compositionStateValue, portIdentifierValue);
 
    // if (isThreadSafe)
    // {
    //   unsigned long eventId = vuoGetNextEventId();
    //   vuoLockNode(compositionState, nodeIndex, eventId);
    // }
 
    BasicBlock *waitBlock = BasicBlock::Create(module->getContext(), "wait", function, 0);
    BasicBlock *checkTypeIndexBlock = BasicBlock::Create(module->getContext(), "checkTypeIndex", function, 0);
    ConstantInt *falseValue = ConstantInt::get(static_cast<IntegerType *>(isThreadSafeValue->getType()), 0);
    ICmpInst *isThreadSafeEqualsTrue = new ICmpInst(*checkWaitBlock, ICmpInst::ICMP_NE, isThreadSafeValue, falseValue, "");
    BranchInst::Create(waitBlock, checkTypeIndexBlock, isThreadSafeEqualsTrue, checkWaitBlock);
 
    Value *eventIdValue = VuoCompilerCodeGenUtilities::generateGetNextEventId(module, waitBlock, compositionStateValue);
    VuoCompilerCodeGenUtilities::generateLockNode(module, waitBlock, compositionStateValue, nodeIndexValue, eventIdValue);
    BranchInst::Create(checkTypeIndexBlock, waitBlock);
 
 
    // if (typeIndex == 0)
    // {
    //   VuoImage portValue = (VuoImage)(*portAddress);
    //   if (serializationType == 0)
    //     ret = VuoImage_getSummary(portValue);
    //   else if (serializationType == 1)
    //     ret = VuoImage_getString(portValue);
    //   else
    //     ret = VuoImage_getInterprocessString(portValue);
    // }
    // else if (typeIndex == 3)
    // {
    //   VuoReal portValue = (VuoReal)(*portAddress);
    //   if (serializationType == 0)
    //     ret = VuoReal_getSummary(portValue);
    //   else
    //     ret = VuoReal_getString(portValue);
    // }
    // else if ...
 
    vector< pair<BasicBlock *, BasicBlock *> > blocksForIndex;
    for (size_t i = 0; i < orderedTypes.size(); ++i)
    {
        VuoCompilerType *type = orderedTypes[i];
 
        string typeName = type->getBase()->getModuleKey();
        bool hasInterprocess = type->hasInterprocessStringFunction();
 
        BasicBlock *checkSummaryBlock = BasicBlock::Create(module->getContext(), typeName + "_checkSummary", function, 0);
        BasicBlock *summaryBlock = BasicBlock::Create(module->getContext(), typeName + "_summary", function, 0);
        BasicBlock *checkStringBlock = NULL;
        BasicBlock *stringBlock = BasicBlock::Create(module->getContext(), typeName + "_string", function, 0);
        BasicBlock *interprocessBlock = NULL;
        BasicBlock *typeFinalBlock = BasicBlock::Create(module->getContext(), typeName + "_final", function, 0);
 
        BasicBlock *firstStringBlock = NULL;
        if (hasInterprocess)
        {
            checkStringBlock = BasicBlock::Create(module->getContext(), typeName + "_checkString", function, 0);
            interprocessBlock = BasicBlock::Create(module->getContext(), typeName + "_interprocess", function, 0);
            firstStringBlock = checkStringBlock;
        }
        else
        {
            firstStringBlock = stringBlock;
        }
 
        ConstantInt *zeroValue = ConstantInt::get(static_cast<IntegerType *>(serializationTypeValue->getType()), 0);
        ICmpInst *serializationTypeEqualsZero = new ICmpInst(*checkSummaryBlock, ICmpInst::ICMP_EQ, serializationTypeValue, zeroValue, "");
        BranchInst::Create(summaryBlock, firstStringBlock, serializationTypeEqualsZero, checkSummaryBlock);
 
        Value *summaryValue = type->generateSummaryFromValueFunctionCall(module, summaryBlock, portAddressAsVoidPointer);
        new StoreInst(summaryValue, retVariable, summaryBlock);
        BranchInst::Create(typeFinalBlock, summaryBlock);
 
        if (hasInterprocess)
        {
            ConstantInt *oneValue = ConstantInt::get(static_cast<IntegerType *>(serializationTypeValue->getType()), 1);
            ICmpInst *serializationTypeEqualsOne = new ICmpInst(*checkStringBlock, ICmpInst::ICMP_EQ, serializationTypeValue, oneValue, "");
            BranchInst::Create(stringBlock, interprocessBlock, serializationTypeEqualsOne, checkStringBlock);
        }
 
        Value *stringValue = type->generateStringFromValueFunctionCall(module, stringBlock, portAddressAsVoidPointer);
        new StoreInst(stringValue, retVariable, stringBlock);
        BranchInst::Create(typeFinalBlock, stringBlock);
 
        if (hasInterprocess)
        {
            Value *interprocessValue = type->generateInterprocessStringFromValueFunctionCall(module, interprocessBlock, portAddressAsVoidPointer);
            new StoreInst(interprocessValue, retVariable, interprocessBlock);
            BranchInst::Create(typeFinalBlock, interprocessBlock);
        }
 
        blocksForIndex.push_back( make_pair(checkSummaryBlock, typeFinalBlock) );
    }
 
    BasicBlock *checkSignalBlock = BasicBlock::Create(module->getContext(), "checkSignal", function, 0);
    VuoCompilerCodeGenUtilities::generateIndexMatchingCode(module, function, checkTypeIndexBlock, checkSignalBlock, typeIndexValue, blocksForIndex);
 
 
    // if (isThreadSafe)
    //   vuoUnlockNode(compositionState, nodeIndex);
 
    BasicBlock *signalBlock = BasicBlock::Create(module->getContext(), "signal", function, 0);
    BranchInst::Create(signalBlock, finalBlock, isThreadSafeEqualsTrue, checkSignalBlock);
 
    VuoCompilerCodeGenUtilities::generateUnlockNode(module, signalBlock, compositionStateValue, nodeIndexValue);
    BranchInst::Create(finalBlock, signalBlock);
 
 
    // return ret;
 
    LoadInst *retValue = new LoadInst(retVariable, "", false, finalBlock);
    ReturnInst::Create(module->getContext(), retValue, finalBlock);
}
 
void VuoCompilerBitcodeGenerator::generateCompositionSetPortValueFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getCompositionSetPortValueFunction(module);
 
    Function::arg_iterator args = function->arg_begin();
    Value *compositionStateValue = args++;
    compositionStateValue->setName("compositionState");
    Value *portIdentifierValue = args++;
    portIdentifierValue->setName("portIdentifier");
    Value *valueAsStringValue = args++;
    valueAsStringValue->setName("valueAsString");
    Value *isThreadSafeValue = args++;
    isThreadSafeValue->setName("isThreadSafe");
    Value *shouldUpdateTriggersValue = args++;
    shouldUpdateTriggersValue->setName("shouldUpdateTriggers");
    Value *shouldSendTelemetryValue = args++;
    shouldSendTelemetryValue->setName("shouldSendTelemetry");
    Value *hasOldValue = args++;
    hasOldValue->setName("hasOldValue");
    Value *hasNewValue = args++;
    hasNewValue->setName("hasNewValue");
 
 
    // void *portAddress = vuoGetDataForPort(compositionState, portIdentifier);
 
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, 0);
    Value *portAddressAsVoidPointer = VuoCompilerCodeGenUtilities::generateGetDataForPort(module, initialBlock, compositionStateValue, portIdentifierValue);
 
    // if (portAddress != NULL)
 
    BasicBlock *checkWaitBlock = BasicBlock::Create(module->getContext(), "checkWait", function, 0);
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, 0);
 
    ConstantPointerNull *nullPortAddress = ConstantPointerNull::get(static_cast<PointerType *>(portAddressAsVoidPointer->getType()));
    ICmpInst *portAddressNotEqualsNull = new ICmpInst(*initialBlock, ICmpInst::ICMP_NE, portAddressAsVoidPointer, nullPortAddress, "");
    BranchInst::Create(checkWaitBlock, finalBlock, portAddressNotEqualsNull, initialBlock);
 
    // dispatch_semaphore_t nodeSemaphore = vuoGetNodeSemaphoreForPort(compositionState, portIdentifier);
    // unsigned long typeIndex = vuoGetTypeIndexForPort(compositionState, portIdentifier);
    // unsigned long nodeIndex = vuoGetNodeIndexForPort(compositionState, portIdentifier);
    // char *summary = NULL;
 
    Value *typeIndexValue = VuoCompilerCodeGenUtilities::generateGetTypeIndexForPort(module, checkWaitBlock, compositionStateValue, portIdentifierValue);
    Value *nodeIndexValue = VuoCompilerCodeGenUtilities::generateGetNodeIndexForPort(module, checkWaitBlock, compositionStateValue, portIdentifierValue);
 
    PointerType *pointerToCharType = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
    AllocaInst *summaryVariable = new AllocaInst(pointerToCharType, 0, "summary", checkWaitBlock);
    ConstantPointerNull *nullSummary = ConstantPointerNull::get(pointerToCharType);
    new StoreInst(nullSummary, summaryVariable, false, checkWaitBlock);
 
    // if (isThreadSafe)
    // {
    //   unsigned long eventId = vuoGetNextEventId();
    //   vuoLockNode(compositionState, nodeIndex, eventId);
    // }
 
    BasicBlock *waitBlock = BasicBlock::Create(module->getContext(), "wait", function, 0);
    BasicBlock *checkTypeIndexBlock = BasicBlock::Create(module->getContext(), "checkTypeIndex", function, 0);
    ConstantInt *falseArgValue = ConstantInt::get(static_cast<IntegerType *>(isThreadSafeValue->getType()), 0);
    ICmpInst *isThreadSafeEqualsTrue = new ICmpInst(*checkWaitBlock, ICmpInst::ICMP_NE, isThreadSafeValue, falseArgValue, "");
    BranchInst::Create(waitBlock, checkTypeIndexBlock, isThreadSafeEqualsTrue, checkWaitBlock);
 
    Value *eventIdValue = VuoCompilerCodeGenUtilities::generateGetNextEventId(module, waitBlock, compositionStateValue);
    VuoCompilerCodeGenUtilities::generateLockNode(module, waitBlock, compositionStateValue, nodeIndexValue, eventIdValue);
    BranchInst::Create(checkTypeIndexBlock, waitBlock);
 
 
    // if (typeIndex == 0)
    // {
    //   VuoText newPortValue;
    //   if (hasNewValue)
    //   {
    //     json_object *js = json_tokener_parse(valueAsString);
    //     newPortValue = VuoText_makeFromJson(js);
    //     VuoRetain(newPortValue);
    //     json_object_put(js);
    //   }
    //   if (hasOldValue)
    //     VuoRelease(*(portContext->data));
    //   if (hasNewValue)
    //   {
    //     memcpy(portContext->data, &newPortValue, sizeof(VuoText));
    //     if (shouldSendTelemetry)
    //       summary = VuoText_getSummary(newPortValue);
    //   }
    // }
    // else if (typeIndex == 1)
    // {
    //   if (hasNewValue)
    //   {
    //     json_object *js = json_tokener_parse(valueAsString);
    //     VuoReal newPortValue = VuoReal_makeFromJson(js);
    //     json_object_put(js);
    //     memcpy(portContext->data, &newPortValue, sizeof(VuoReal));
    //     if (shouldSendTelemetry)
    //       summary = VuoReal_getSummary(newPortValue);
    //   }
    // }
    // else if ...
 
    ICmpInst *hasOldValueIsTrue = new ICmpInst(*checkTypeIndexBlock, ICmpInst::ICMP_NE, hasOldValue, falseArgValue, "");
    ICmpInst *hasNewValueIsTrue = new ICmpInst(*checkTypeIndexBlock, ICmpInst::ICMP_NE, hasNewValue, falseArgValue, "");
    ICmpInst *shouldSendTelemetryIsTrue = new ICmpInst(*checkTypeIndexBlock, ICmpInst::ICMP_NE, shouldSendTelemetryValue, falseArgValue, "");
 
    vector< pair<BasicBlock *, BasicBlock *> > blocksForTypeIndex;
    for (size_t i = 0; i < orderedTypes.size(); ++i)
    {
        VuoCompilerType *type = orderedTypes[i];
 
        BasicBlock *typeInitialBlock = BasicBlock::Create(module->getContext(), type->getBase()->getModuleKey() + "_initial", function, 0);
        BasicBlock *makeNewValueBlock = BasicBlock::Create(module->getContext(), "makeNewValue", function, 0);
        BasicBlock *checkOldValueBlock = BasicBlock::Create(module->getContext(), "checkOldValue", function, 0);
        BasicBlock *releaseOldValueBlock = BasicBlock::Create(module->getContext(), "releaseOldValue", function, 0);
        BasicBlock *checkNewValueBlock = BasicBlock::Create(module->getContext(), "checkNewValue", function, 0);
        BasicBlock *setNewValueBlock = BasicBlock::Create(module->getContext(), "setNewValue", function, 0);
        BasicBlock *summaryBlock = BasicBlock::Create(module->getContext(), "summary", function, 0);
        BasicBlock *typeFinalBlock = BasicBlock::Create(module->getContext(), type->getBase()->getModuleKey() + "_final", function, 0);
 
        Value *portAddress = type->convertToPortData(typeInitialBlock, portAddressAsVoidPointer);
        AllocaInst *newPortValueAddress = new AllocaInst(cast<PointerType>(portAddress->getType())->getElementType(), 0, "newPortValueAddress", typeInitialBlock);
 
        BranchInst::Create(makeNewValueBlock, checkOldValueBlock, hasNewValueIsTrue, typeInitialBlock);
 
        Value *newPortValueAddressLocal = type->generateRetainedValueFromString(module, makeNewValueBlock, valueAsStringValue);
        VuoCompilerCodeGenUtilities::generateMemoryCopy(module, makeNewValueBlock, newPortValueAddressLocal, newPortValueAddress, type);
 
        BranchInst::Create(checkOldValueBlock, makeNewValueBlock);
 
        BranchInst::Create(releaseOldValueBlock, checkNewValueBlock, hasOldValueIsTrue, checkOldValueBlock);
 
        type->generateReleaseCall(module, releaseOldValueBlock, portAddress);
        BranchInst::Create(checkNewValueBlock, releaseOldValueBlock);
 
        BranchInst::Create(setNewValueBlock, typeFinalBlock, hasNewValueIsTrue, checkNewValueBlock);
 
        VuoCompilerCodeGenUtilities::generateMemoryCopy(module, setNewValueBlock, newPortValueAddress, portAddress, type);
        BranchInst::Create(summaryBlock, typeFinalBlock, shouldSendTelemetryIsTrue, setNewValueBlock);
 
        Value *summaryValue = type->generateSummaryFromValueFunctionCall(module, summaryBlock, portAddress);
        new StoreInst(summaryValue, summaryVariable, false, summaryBlock);
        BranchInst::Create(typeFinalBlock, summaryBlock);
 
        blocksForTypeIndex.push_back( make_pair(typeInitialBlock, typeFinalBlock) );
    }
 
    BasicBlock *checkUpdateBlock = BasicBlock::Create(module->getContext(), "checkUpdate", function, 0);
    VuoCompilerCodeGenUtilities::generateIndexMatchingCode(module, function, checkTypeIndexBlock, checkUpdateBlock, typeIndexValue, blocksForTypeIndex);
 
 
    // if (shouldUpdateTriggers)
    // {
    //   if (nodeIndex == 0)
    //   {
    //     Top__FirePeriodically2__fired(...);
    //   }
    //   else if ...
    // }
 
    Constant *zeroValue = ConstantInt::get(shouldUpdateTriggersValue->getType(), 0);
    ICmpInst *shouldUpdateTriggersIsTrue = new ICmpInst(*checkUpdateBlock, ICmpInst::ICMP_NE, shouldUpdateTriggersValue, zeroValue, "");
    BasicBlock *updateTriggersBlock = BasicBlock::Create(module->getContext(), "updateTriggers", function, 0);
    BasicBlock *checkSendBlock = BasicBlock::Create(module->getContext(), "checkSend", function, 0);
    BranchInst::Create(updateTriggersBlock, checkSendBlock, shouldUpdateTriggersIsTrue, checkUpdateBlock);
 
    vector< pair<BasicBlock *, BasicBlock *> > blocksForNodeIndex;
    for (size_t i = 0; i < orderedNodes.size(); ++i)
    {
        VuoCompilerNode *node = orderedNodes[i];
        BasicBlock *currentBlock = BasicBlock::Create(module->getContext(), node->getIdentifier(), function, 0);
        BasicBlock *origCurrentBlock = currentBlock;
 
        node->generateCallbackUpdateFunctionCall(module, currentBlock, compositionStateValue);
 
        generateDataOnlyTransmissionFromNode(function, currentBlock, compositionStateValue, node, true, true, true);
 
        blocksForNodeIndex.push_back( make_pair(origCurrentBlock, currentBlock) );
    }
 
    BasicBlock *checkSignalBlock = BasicBlock::Create(module->getContext(), "checkSignal", function, 0);
    VuoCompilerCodeGenUtilities::generateIndexMatchingCode(module, function, updateTriggersBlock, checkSignalBlock, nodeIndexValue, blocksForNodeIndex);
 
 
    // if (isThreadSafe)
    //   vuoUnlockNode(compositionState, nodeIndex);
 
    BasicBlock *signalBlock = BasicBlock::Create(module->getContext(), "signal", function, 0);
    BranchInst::Create(signalBlock, checkSendBlock, isThreadSafeEqualsTrue, checkSignalBlock);
 
    VuoCompilerCodeGenUtilities::generateUnlockNode(module, signalBlock, compositionStateValue, nodeIndexValue);
    BranchInst::Create(checkSendBlock, signalBlock);
 
 
    // if (shouldSendTelemetry)
    // {
    //   sendInputPortsUpdated(portIdentifier, false, true, summary);
    //   free(summary);
    // }
 
    BasicBlock *sendBlock = BasicBlock::Create(module->getContext(), "send", function, 0);
    BranchInst::Create(sendBlock, finalBlock, shouldSendTelemetryIsTrue, checkSendBlock);
 
    Value *summaryValue = new LoadInst(summaryVariable, "", false, sendBlock);
 
    VuoCompilerCodeGenUtilities::generateSendInputPortsUpdated(module, sendBlock, compositionStateValue, portIdentifierValue,
                                                               false, true, summaryValue);
 
    VuoCompilerCodeGenUtilities::generateFreeCall(module, sendBlock, summaryValue);
    BranchInst::Create(finalBlock, sendBlock);
 
    ReturnInst::Create(module->getContext(), finalBlock);
}
 
void VuoCompilerBitcodeGenerator::generateSetInputPortValueFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getSetInputPortValueFunction(module);
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
 
    Function::arg_iterator args = function->arg_begin();
    Value *portIdentifierValue = args++;
    portIdentifierValue->setName("portIdentifier");
    Value *valueAsStringValue = args++;
    valueAsStringValue->setName("valueAsString");
 
    Function *compositionSetPortValueFunction = VuoCompilerCodeGenUtilities::getCompositionSetPortValueFunction(module);
 
    Value *topLevelRuntimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, block);
    Value *topLevelCompositionIdentifierValue = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
    Value *compositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, topLevelRuntimeStateValue, topLevelCompositionIdentifierValue);
 
    Value *trueValue = ConstantInt::get(compositionSetPortValueFunction->getFunctionType()->getParamType(3), 1);
 
    vector<Value *> compositionArgs;
    compositionArgs.push_back(compositionStateValue);
    compositionArgs.push_back(portIdentifierValue);
    compositionArgs.push_back(valueAsStringValue);
    compositionArgs.push_back(trueValue);
    compositionArgs.push_back(trueValue);
    compositionArgs.push_back(trueValue);
    compositionArgs.push_back(trueValue);
    compositionArgs.push_back(trueValue);
    CallInst::Create(compositionSetPortValueFunction, compositionArgs, "", block);
 
    VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, compositionStateValue);
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateCompositionFireTriggerPortEventFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getCompositionFireTriggerPortEventFunction(module);
 
    Function::arg_iterator args = function->arg_begin();
    Value *compositionStateValue = args++;
    compositionStateValue->setName("compositionState");
    Value *portIdentifierValue = args++;
    portIdentifierValue->setName("portIdentifier");
 
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, 0);
 
    map<string, pair<BasicBlock *, BasicBlock *> > blocksForString;
    for (VuoCompilerTriggerPort *trigger : graph->getTriggerPorts())
    {
        VuoCompilerNode *triggerNode = graph->getNodeForTriggerPort(trigger);
 
        string currentPortIdentifier = trigger->getIdentifier();
 
        BasicBlock *currentBlock = BasicBlock::Create(module->getContext(), currentPortIdentifier, function, 0);
        BasicBlock *origCurrentBlock = currentBlock;
 
        Value *nodeContextValue = triggerNode->generateGetContext(module, currentBlock, compositionStateValue);
        Value *triggerFunctionValue = trigger->generateLoadFunction(module, currentBlock, nodeContextValue);
 
        vector<Value *> triggerArgs;
        VuoType *dataType = trigger->getDataVuoType();
        if (dataType)
        {
            generateLockNodes(module, currentBlock, compositionStateValue, vector<VuoCompilerNode *>(1, triggerNode));
 
            FunctionType *triggerFunctionType = trigger->getClass()->getFunctionType(module);
 
            Value *dataPointer = trigger->generateRetrievePreviousData(module, currentBlock, nodeContextValue);
            triggerArgs = dataType->getCompiler()->convertPortDataToArgs(module, currentBlock, dataPointer, triggerFunctionType, 0, false);
        }
 
        CallInst *call = CallInst::Create(triggerFunctionValue, triggerArgs, "", currentBlock);
 
        if (dataType)
        {
            dataType->getCompiler()->copyFunctionParameterAttributes(module, call);
 
            generateUnlockNodes(module, currentBlock, compositionStateValue, vector<VuoCompilerNode *>(1, triggerNode));
        }
 
        blocksForString[currentPortIdentifier] = make_pair(origCurrentBlock, currentBlock);
    }
 
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, 0);
 
    ReturnInst::Create(module->getContext(), finalBlock);
 
    VuoCompilerCodeGenUtilities::generateStringMatchingCode(module, function, initialBlock, finalBlock, portIdentifierValue, blocksForString, constantsCache);
}
 
void VuoCompilerBitcodeGenerator::generateGetPublishedPortCountFunction(bool input)
{
    size_t count;
    string functionName;
    if (input)
    {
        count = composition->getBase()->getPublishedInputPorts().size();
        functionName = "getPublishedInputPortCount";
    }
    else
    {
        count = composition->getBase()->getPublishedOutputPorts().size();
        functionName = "getPublishedOutputPortCount";
    }
 
    Function *function = module->getFunction(functionName);
    if (! function)
    {
        vector<Type *> functionParams;
        FunctionType *functionType = FunctionType::get(IntegerType::get(module->getContext(), 32), functionParams, false);
        function = Function::Create(functionType, GlobalValue::ExternalLinkage, functionName, module);
    }
 
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, 0);
    ConstantInt *countConstant = ConstantInt::get(module->getContext(), APInt(32, count));
    ReturnInst::Create(module->getContext(), countConstant, block);
}
 
void VuoCompilerBitcodeGenerator::generateGetPublishedPortNamesFunction(bool input)
{
    string functionName;
    vector<VuoPublishedPort *> publishedPorts;
    if (input)
    {
        functionName = "getPublishedInputPortNames";
        publishedPorts = composition->getBase()->getPublishedInputPorts();
    }
    else
    {
        functionName = "getPublishedOutputPortNames";
        publishedPorts = composition->getBase()->getPublishedOutputPorts();
    }
 
    vector<string> names;
    for (vector<VuoPublishedPort *>::iterator i = publishedPorts.begin(); i != publishedPorts.end(); ++i)
    {
        names.push_back( (*i)->getClass()->getName() );
    }
 
    generateFunctionReturningStringArray(functionName, names);
}
 
void VuoCompilerBitcodeGenerator::generateGetPublishedPortTypesFunction(bool input)
{
    string functionName;
    vector<VuoPublishedPort *> publishedPorts;
    if (input)
    {
        functionName = "getPublishedInputPortTypes";
        publishedPorts = composition->getBase()->getPublishedInputPorts();
    }
    else
    {
        functionName = "getPublishedOutputPortTypes";
        publishedPorts = composition->getBase()->getPublishedOutputPorts();
    }
 
    vector<string> types;
    for (vector<VuoPublishedPort *>::iterator i = publishedPorts.begin(); i != publishedPorts.end(); ++i)
    {
        VuoCompilerPublishedPort *publishedPort = static_cast<VuoCompilerPublishedPort *>((*i)->getCompiler());
 
        VuoType *type = publishedPort->getDataVuoType();
        string typeName = type ? type->getModuleKey() : "";
        types.push_back(typeName);
    }
 
    generateFunctionReturningStringArray(functionName, types);
}
 
void VuoCompilerBitcodeGenerator::generateGetPublishedPortDetailsFunction(bool input)
{
    string functionName;
    vector<VuoPublishedPort *> publishedPorts;
    if (input)
    {
        functionName = "getPublishedInputPortDetails";
        publishedPorts = composition->getBase()->getPublishedInputPorts();
    }
    else
    {
        functionName = "getPublishedOutputPortDetails";
        publishedPorts = composition->getBase()->getPublishedOutputPorts();
    }
 
    vector<string> details;
    for (vector<VuoPublishedPort *>::iterator i = publishedPorts.begin(); i != publishedPorts.end(); ++i)
    {
        VuoCompilerPublishedPort *publishedPort = static_cast<VuoCompilerPublishedPort *>((*i)->getCompiler());
 
        json_object *detailsObj = publishedPort->getDetails(input);
        string detailsSerialized = json_object_to_json_string_ext(detailsObj, JSON_C_TO_STRING_PLAIN);
        details.push_back(detailsSerialized);
 
        json_object_put(detailsObj);
    }
 
    generateFunctionReturningStringArray(functionName, details);
}
 
void VuoCompilerBitcodeGenerator::generateFunctionReturningStringArray(string functionName, vector<string> stringValues)
{
    Function *function = module->getFunction(functionName);
    if (! function)
    {
        PointerType *pointerToChar = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
        PointerType *pointerToPointerToChar = PointerType::get(pointerToChar, 0);
        vector<Type *> functionParams;
        FunctionType *functionType = FunctionType::get(pointerToPointerToChar, functionParams, false);
        function = Function::Create(functionType, GlobalValue::ExternalLinkage, functionName, module);
    }
 
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, 0);
 
    Constant *stringArrayGlobalPointer = VuoCompilerCodeGenUtilities::generatePointerToConstantArrayOfStrings(module, stringValues);
    ReturnInst::Create(module->getContext(), stringArrayGlobalPointer, block);
}
 
void VuoCompilerBitcodeGenerator::generateFirePublishedInputPortEventFunction(void)
{
    string functionName = "firePublishedInputPortEvent";
    Function *function = module->getFunction(functionName);
    PointerType *pointerToChar = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
    if (! function)
    {
        PointerType *pointerToPointerToChar = PointerType::get(pointerToChar, 0);
        Type *countType = IntegerType::get(module->getContext(), 32);
 
        vector<Type *> functionParams;
        functionParams.push_back(pointerToPointerToChar);
        functionParams.push_back(countType);
        FunctionType *functionType = FunctionType::get(Type::getVoidTy(module->getContext()), functionParams, false);
        function = Function::Create(functionType, GlobalValue::ExternalLinkage, functionName, module);
    }
 
    Function::arg_iterator args = function->arg_begin();
    Value *namesValue = args++;
    namesValue->setName("names");
    Value *countValue = args++;
    countValue->setName("count");
 
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, 0);
 
    VuoCompilerTriggerPort *trigger = graph->getPublishedInputTrigger();
    if (! trigger)
    {
        ReturnInst::Create(module->getContext(), initialBlock);
        return;
    }
 
    VuoCompilerNode *triggerNode = graph->getNodeForTriggerPort(trigger);
 
    Value *runtimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, initialBlock);
    Value *compositionIdentifierValue = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
    Value *compositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, initialBlock, runtimeStateValue,
                                                                                               compositionIdentifierValue);
 
    // Create an event ID so the nodes claimed by this function can be used (re-claimed) by the trigger worker.
 
    Value *eventIdValue = VuoCompilerCodeGenUtilities::generateGetNextEventId(module, initialBlock, compositionStateValue);
 
    // Claim all necessary downstream nodes —
    // including the published output node to synchronize access to the composition's node context when tracking events started/finished.
 
    vector<VuoCompilerNode *> triggerWaitNodes = getNodesToWaitOnBeforeTransmission(trigger);
 
    VuoCompilerNode *publishedOutputNode = graph->getPublishedOutputNode();
    if (find(triggerWaitNodes.begin(), triggerWaitNodes.end(), publishedOutputNode) == triggerWaitNodes.end())
        triggerWaitNodes.push_back(publishedOutputNode);
 
    generateLockNodes(module, initialBlock, compositionStateValue, triggerWaitNodes, eventIdValue);
 
    // Start tracking the event so we can later notify the runner when the event is finished.
 
    Value *compositionContextValue = VuoCompilerCodeGenUtilities::generateGetCompositionContext(module, initialBlock, compositionStateValue);
    VuoCompilerCodeGenUtilities::generateStartedExecutingEvent(module, initialBlock, compositionContextValue, eventIdValue);
 
    // Mark the selected input ports on the published input node as hit by an event.
    //
    // int i = 0;
    // while (i < count)
    // {
    //    if (! strcmp(names[i], "firstPort"))
    //    {
    //       ...
    //    }
    //    else if (! strcmp(names[i], "secondPort"))
    //    {
    //       ...
    //    }
    //    i = i + 1;
    // }
    //
 
    VuoCompilerNode *publishedInputNode = graph->getPublishedInputNode();
    Value *publishedInputNodeContextValue = publishedInputNode->generateGetContext(module, initialBlock, compositionStateValue);
 
    Value *zeroValue = ConstantInt::get(static_cast<IntegerType *>(countValue->getType()), 0);
    AllocaInst *iterVariable = new AllocaInst(countValue->getType(), 0, "i", initialBlock);
    new StoreInst(zeroValue, iterVariable, false, initialBlock);
 
    BasicBlock *loopConditionBlock = BasicBlock::Create(module->getContext(), "loopCondition", function, 0);
    BasicBlock *loopBeginBlock = BasicBlock::Create(module->getContext(), "loopBegin", function, 0);
    BasicBlock *loopEndBlock = BasicBlock::Create(module->getContext(), "loopEnd", function, 0);
    BasicBlock *fireBlock = BasicBlock::Create(module->getContext(), "fire", function, 0);
 
    BranchInst::Create(loopConditionBlock, initialBlock);
 
    Value *iterValue = new LoadInst(iterVariable, "", false, loopConditionBlock);
    ICmpInst *iterLessThanCount = new ICmpInst(*loopConditionBlock, ICmpInst::ICMP_ULT, iterValue, countValue, "");
    BranchInst::Create(loopBeginBlock, fireBlock, iterLessThanCount, loopConditionBlock);
 
    Value *iterNameValue = VuoCompilerCodeGenUtilities::generateGetArrayElement(module, loopBeginBlock, namesValue, iterValue);
 
    map<string, pair<BasicBlock *, BasicBlock *> > blocksForString;
 
    vector<VuoPublishedPort *> publishedInputPorts = composition->getBase()->getPublishedInputPorts();
    for (size_t i = 0; i < publishedInputPorts.size(); ++i)
    {
        string currentName = publishedInputPorts[i]->getClass()->getName();
        BasicBlock *currentBlock = BasicBlock::Create(module->getContext(), currentName, function, 0);
 
        VuoPort *port = graph->getInputPortOnPublishedInputNode(i);
        VuoCompilerInputEventPort *inputEventPort = static_cast<VuoCompilerInputEventPort *>(port->getCompiler());
        inputEventPort->generateStoreEvent(module, currentBlock, publishedInputNodeContextValue, true);
 
        blocksForString[currentName] = make_pair(currentBlock, currentBlock);
    }
 
    VuoCompilerCodeGenUtilities::generateStringMatchingCode(module, function, loopBeginBlock, loopEndBlock, iterNameValue, blocksForString, constantsCache);
 
    Value *oneValue = ConstantInt::get(static_cast<IntegerType *>(countValue->getType()), 1);
    Value *iterPlusOneValue = BinaryOperator::Create(Instruction::Add, iterValue, oneValue, "", loopEndBlock);
    new StoreInst(iterPlusOneValue, iterVariable, false, loopEndBlock);
 
    BranchInst::Create(loopConditionBlock, loopEndBlock);
 
    // Fire an event from the published input trigger.
 
    Value *triggerNodeContextValue = triggerNode->generateGetContext(module, fireBlock, compositionStateValue);
    Value *triggerFunctionValue = trigger->generateLoadFunction(module, fireBlock, triggerNodeContextValue);
    CallInst::Create(triggerFunctionValue, "", fireBlock);
 
    VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, fireBlock, compositionStateValue);
 
    ReturnInst::Create(module->getContext(), fireBlock);
}
 
void VuoCompilerBitcodeGenerator::generateGetPublishedPortValueFunction(bool input)
{
    Function *function = (input ?
                              VuoCompilerCodeGenUtilities::getGetPublishedInputPortValueFunction(module) :
                              VuoCompilerCodeGenUtilities::getGetPublishedOutputPortValueFunction(module));
 
    Function::arg_iterator args = function->arg_begin();
    Value *portIdentifierValue = args++;
    portIdentifierValue->setName("portIdentifier");
    Value *shouldUseInterprocessSerializationValue = args++;
    shouldUseInterprocessSerializationValue->setName("shouldUseInterprocessSerialization");
 
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, 0);
    PointerType *pointerToChar = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
    AllocaInst *retVariable = new AllocaInst(pointerToChar, 0, "ret", initialBlock);
    ConstantPointerNull *nullValue = ConstantPointerNull::get(pointerToChar);
    new StoreInst(nullValue, retVariable, false, initialBlock);
 
    Value *runtimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, initialBlock);
    Value *compositionIdentifierValue = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
    Value *compositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, initialBlock, runtimeStateValue,
                                                                                               compositionIdentifierValue);
 
    vector<VuoPort *> inputPortsOnPublishedNode;
    if (input)
    {
        vector<VuoPublishedPort *> publishedPorts = composition->getBase()->getPublishedInputPorts();
        for (size_t i = 0; i < publishedPorts.size(); ++i)
        {
            VuoPort *port = graph->getInputPortOnPublishedInputNode(i);
            inputPortsOnPublishedNode.push_back(port);
        }
    }
    else
    {
        vector<VuoPublishedPort *> publishedPorts = composition->getBase()->getPublishedOutputPorts();
        for (size_t i = 0; i < publishedPorts.size(); ++i)
        {
            VuoPort *port = graph->getInputPortOnPublishedOutputNode(i);
            inputPortsOnPublishedNode.push_back(port);
        }
    }
 
    map<string, pair<BasicBlock *, BasicBlock *> > blocksForString;
    for (VuoPort *port : inputPortsOnPublishedNode)
    {
        string currentName = port->getClass()->getName();
        BasicBlock *currentBlock = BasicBlock::Create(module->getContext(), currentName, function, 0);
 
        string currentIdentifier = static_cast<VuoCompilerEventPort *>(port->getCompiler())->getIdentifier();
        Constant *currentIdentifierValue = constantsCache->get(currentIdentifier);
 
        Value *retValue = VuoCompilerCodeGenUtilities::generateGetInputPortString(module, currentBlock, compositionStateValue,
                                                                                  currentIdentifierValue, shouldUseInterprocessSerializationValue);
        new StoreInst(retValue, retVariable, currentBlock);
 
        blocksForString[currentName] = make_pair(currentBlock, currentBlock);
    }
 
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, 0);
 
    VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, finalBlock, compositionStateValue);
 
    LoadInst *retValue = new LoadInst(retVariable, "", false, finalBlock);
    ReturnInst::Create(module->getContext(), retValue, finalBlock);
 
    VuoCompilerCodeGenUtilities::generateStringMatchingCode(module, function, initialBlock, finalBlock, portIdentifierValue, blocksForString, constantsCache);
}
 
void VuoCompilerBitcodeGenerator::generateCompositionSetPublishedInputPortValueFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getCompositionSetPublishedInputPortValueFunction(module);
 
    Function::arg_iterator args = function->arg_begin();
    Value *compositionStateValue = args++;
    compositionStateValue->setName("compositionState");
    Value *publishedInputPortNameValue = args++;
    publishedInputPortNameValue->setName("publishedInputPortName");
    Value *valueAsStringValue = args++;
    valueAsStringValue->setName("valueAsString");
    Value *isCompositionRunningValue = args++;
    isCompositionRunningValue->setName("isCompositionRunning");
 
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, 0);
 
    VuoCompilerTriggerPort *trigger = graph->getPublishedInputTrigger();
    if (! trigger)
    {
        ReturnInst::Create(module->getContext(), initialBlock);
        return;
    }
 
    // const char *inputPortIdentifier = NULL;
 
    PointerType *pointerToCharType = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
    AllocaInst *inputPortIdentifierVariable = new AllocaInst(pointerToCharType, 0, "inputPortIdentifier", initialBlock);
    ConstantPointerNull *nullInputPortIdentifier = ConstantPointerNull::get(pointerToCharType);
    new StoreInst(nullInputPortIdentifier, inputPortIdentifierVariable, false, initialBlock);
 
    // if (! strcmp(publishedInputPortName, "firstName"))
    //     inputPortIdentifier = "PublishedInputs__firstName";
    // else if (! strcmp(publishedInputPortName, "secondName"))
    //     inputPortIdentifier = "PublishedInputs__secondName";
    // ...
 
    map<string, pair<BasicBlock *, BasicBlock *> > blocksForString;
    vector<VuoPublishedPort *> publishedInputPorts = composition->getBase()->getPublishedInputPorts();
    for (size_t i = 0; i < publishedInputPorts.size(); ++i)
    {
        string currPublishedInputPortName = publishedInputPorts[i]->getClass()->getName();
        BasicBlock *currBlock = BasicBlock::Create(module->getContext(), currPublishedInputPortName, function, 0);
 
        VuoPort *inputPort = graph->getInputPortOnPublishedInputNode(i);
        string inputPortIdentifier = static_cast<VuoCompilerPort *>(inputPort->getCompiler())->getIdentifier();
        Value *inputPortIdentifierValue = constantsCache->get(inputPortIdentifier);
 
        new StoreInst(inputPortIdentifierValue, inputPortIdentifierVariable, false, currBlock);
 
        blocksForString[currPublishedInputPortName] = make_pair(currBlock, currBlock);
    }
 
    BasicBlock *checkBlock = BasicBlock::Create(module->getContext(), "check", function, 0);
    BasicBlock *scheduleBlock = BasicBlock::Create(module->getContext(), "schedule", function, 0);
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, 0);
 
    VuoCompilerCodeGenUtilities::generateStringMatchingCode(module, function, initialBlock, checkBlock, publishedInputPortNameValue, blocksForString, constantsCache);
 
    // if (inputPortIdentifier != NULL)
    // {
 
    Value *inputPortIdentifierValue = new LoadInst(inputPortIdentifierVariable, "", false, checkBlock);
    ICmpInst *portIdentifierNotEqualsNull = new ICmpInst(*checkBlock, ICmpInst::ICMP_NE, inputPortIdentifierValue, nullInputPortIdentifier, "");
    BranchInst::Create(scheduleBlock, finalBlock, portIdentifierNotEqualsNull, checkBlock);
 
    //     void **context = (void **)malloc(4 * sizeof(void *));
    //     context[0] = (void *)compositionState;
    //     context[1] = (void *)inputPortIdentifier;
    //     context[2] = (void *)valueAsString;
    //     context[3] = (void *)isCompositionRunning;
 
    Value *contextValue = VuoCompilerCodeGenUtilities::generateCreatePublishedInputWorkerContext(module, scheduleBlock, compositionStateValue,
                                                                                                 inputPortIdentifierValue, valueAsStringValue,
                                                                                                 isCompositionRunningValue);
 
    //     dispatch_sync(PublishedInputsTrigger__queue, context, PublishedInputPorts__setWorker);
    // }
 
    VuoCompilerNode *triggerNode = graph->getNodeForTriggerPort(trigger);
    Value *nodeContextValue = triggerNode->generateGetContext(module, scheduleBlock, compositionStateValue);
    string workerFunctionName = VuoStringUtilities::transcodeToIdentifier(VuoNodeClass::publishedInputNodeClassName) + "__setWorker";
 
    Function *workerFunction = trigger->generateSynchronousSubmissionToDispatchQueue(module, scheduleBlock, nodeContextValue,
                                                                                     workerFunctionName, contextValue);
 
    BranchInst::Create(finalBlock, scheduleBlock);
    ReturnInst::Create(module->getContext(), finalBlock);
 
    // void PublishedInputPorts__firstName__worker(void *context)
    // {
 
    Function *compositionSetPortValueFunction = VuoCompilerCodeGenUtilities::getCompositionSetPortValueFunction(module);
 
    Function::arg_iterator workerArgs = workerFunction->arg_begin();
    Value *contextValueInWorker = workerArgs++;
    contextValueInWorker->setName("context");
 
    BasicBlock *workerBlock = BasicBlock::Create(module->getContext(), "", workerFunction, 0);
 
    //     VuoCompositionState *compositionState = (VuoCompositionState *)((void **)context)[0];
    //     char *inputPortIdentifier = (char *)((void **)context)[1];
    //     char *valueAsString = (char *)((void **)context)[2];
    //     bool isCompositionRunning = (bool)((void **)context)[3];
 
    Type *voidPointerType = contextValueInWorker->getType();
    Type *voidPointerPointerType = PointerType::get(voidPointerType, 0);
    Type *compositionStatePointerType = PointerType::get(VuoCompilerCodeGenUtilities::getCompositionStateType(module), 0);
    Type *boolType = compositionSetPortValueFunction->getFunctionType()->getParamType(3);
 
    Value *contextValueAsVoidPointerArray = new BitCastInst(contextValueInWorker, voidPointerPointerType, "", workerBlock);
    Value *compositionStateAsVoidPointer = VuoCompilerCodeGenUtilities::generateGetArrayElement(module, workerBlock, contextValueAsVoidPointerArray, (size_t)0);
    Value *compositionStateValueInWorker = new BitCastInst(compositionStateAsVoidPointer, compositionStatePointerType, "", workerBlock);
 
    Value *inputPortIdentifierAsVoidPointer = VuoCompilerCodeGenUtilities::generateGetArrayElement(module, workerBlock, contextValueAsVoidPointerArray, 1);
    Value *inputPortIdentifierValueInWorker = new BitCastInst(inputPortIdentifierAsVoidPointer, pointerToCharType, "", workerBlock);
 
    Value *valueAsStringValueAsVoidPointer = VuoCompilerCodeGenUtilities::generateGetArrayElement(module, workerBlock, contextValueAsVoidPointerArray, 2);
    Value *valueAsStringValueInWorker = new BitCastInst(valueAsStringValueAsVoidPointer, pointerToCharType, "", workerBlock);
 
    Value *isCompositionRunningValueAsVoidPointer = VuoCompilerCodeGenUtilities::generateGetArrayElement(module, workerBlock, contextValueAsVoidPointerArray, 3);
    Value *isCompositionRunningValueInWorker = new PtrToIntInst(isCompositionRunningValueAsVoidPointer, boolType, "", workerBlock);
 
    //     free(context);
 
    VuoCompilerCodeGenUtilities::generateFreeCall(module, workerBlock, contextValueInWorker);
 
    //     compositionSetPortValue(compositionState, portIdentifier, valueAsString, isCompositionRunning, isCompositionRunning, isCompositionRunning, true, true);
    // }
 
    Value *trueValue = ConstantInt::get(boolType, 1);
 
    vector<Value *> setValueArgs;
    setValueArgs.push_back(compositionStateValueInWorker);
    setValueArgs.push_back(inputPortIdentifierValueInWorker);
    setValueArgs.push_back(valueAsStringValueInWorker);
    setValueArgs.push_back(isCompositionRunningValueInWorker);
    setValueArgs.push_back(isCompositionRunningValueInWorker);
    setValueArgs.push_back(isCompositionRunningValueInWorker);
    setValueArgs.push_back(trueValue);
    setValueArgs.push_back(trueValue);
    CallInst::Create(compositionSetPortValueFunction, setValueArgs, "", workerBlock);
 
    ReturnInst::Create(module->getContext(), workerBlock);
}
 
void VuoCompilerBitcodeGenerator::generateSetPublishedInputPortValueFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getSetPublishedInputPortValueFunction(module);
 
    Function::arg_iterator args = function->arg_begin();
    Value *publishedInputPortNameValue = args++;
    publishedInputPortNameValue->setName("publishedInputPortName");
    Value *valueAsStringValue = args++;
    valueAsStringValue->setName("valueAsString");
 
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
 
    Function *compositionFunction = VuoCompilerCodeGenUtilities::getCompositionSetPublishedInputPortValueFunction(module);
 
    Value *topLevelRuntimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, block);
    Value *topLevelCompositionIdentifierValue = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
    Value *compositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, topLevelRuntimeStateValue, topLevelCompositionIdentifierValue);
    Value *trueValue = ConstantInt::get(compositionFunction->getFunctionType()->getParamType(3), 1);
 
    vector<Value *> compositionArgs;
    compositionArgs.push_back(compositionStateValue);
    compositionArgs.push_back(publishedInputPortNameValue);
    compositionArgs.push_back(valueAsStringValue);
    compositionArgs.push_back(trueValue);
    CallInst::Create(compositionFunction, compositionArgs, "", block);
 
    VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, compositionStateValue);
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateTransmissionFromOutputPort(Function *function, BasicBlock *&currentBlock,
                                                                     Value *compositionStateValue,
                                                                     VuoCompilerNode *outputNode, VuoCompilerPort *outputPort,
                                                                     Value *eventValue, Value *dataPointer,
                                                                     bool requiresEvent, bool shouldSendTelemetry)
{
    IntegerType *boolType = IntegerType::get(module->getContext(), 1);
    PointerType *pointerToCharType = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
 
    set<VuoCompilerCable *> outgoingCables = graph->getOutgoingCables(outputPort);
 
    Constant *trueValue = ConstantInt::get(boolType, 1);
    Constant *falseValue = ConstantInt::get(boolType, 0);
    Constant *transmittedEventValue = (requiresEvent ? trueValue : falseValue);
 
    // char *dataSummary = NULL;
    AllocaInst *dataSummaryVariable = new AllocaInst(pointerToCharType, 0, "dataSummary", currentBlock);
    new StoreInst(ConstantPointerNull::get(pointerToCharType), dataSummaryVariable, currentBlock);
 
    map<VuoCompilerPort *, ICmpInst *> shouldSummarizeInput;
    if (shouldSendTelemetry)
    {
        // bool sentData = false;
        AllocaInst *sentDataVariable = new AllocaInst(boolType, 0, "sentData", currentBlock);
        new StoreInst(falseValue, sentDataVariable, currentBlock);
 
        for (set<VuoCompilerCable *>::iterator i = outgoingCables.begin(); i != outgoingCables.end(); ++i)
        {
            VuoCompilerCable *cable = *i;
 
            VuoCompilerPort *inputPort = static_cast<VuoCompilerPort *>(cable->getBase()->getToPort()->getCompiler());
            ICmpInst *shouldSendDataForInput = VuoCompilerCodeGenUtilities::generateShouldSendDataTelemetryComparison(module, currentBlock,
                                                                                                                      inputPort->getIdentifier(),
                                                                                                                      compositionStateValue,
                                                                                                                      constantsCache);
            shouldSummarizeInput[inputPort] = shouldSendDataForInput;
        }
 
        if (dataPointer)
        {
            Value *shouldSummarizeOutput = VuoCompilerCodeGenUtilities::generateShouldSendDataTelemetryComparison(module, currentBlock,
                                                                                                                  outputPort->getIdentifier(),
                                                                                                                  compositionStateValue,
                                                                                                                  constantsCache);
 
            for (set<VuoCompilerCable *>::iterator i = outgoingCables.begin(); i != outgoingCables.end(); ++i)
            {
                VuoCompilerCable *cable = *i;
 
                if (cable->carriesData())
                {
                    VuoCompilerPort *inputPort = static_cast<VuoCompilerPort *>(cable->getBase()->getToPort()->getCompiler());
                    shouldSummarizeOutput = BinaryOperator::Create(Instruction::Or, shouldSummarizeOutput, shouldSummarizeInput[inputPort], "", currentBlock);
                }
            }
 
            BasicBlock *summaryBlock = BasicBlock::Create(module->getContext(), "outputSummary", function, NULL);
            BasicBlock *sendOutputBlock = BasicBlock::Create(module->getContext(), "sendOutput", function, NULL);
            BranchInst::Create(summaryBlock, sendOutputBlock, shouldSummarizeOutput, currentBlock);
 
            // sentData = true;
            new StoreInst(trueValue, sentDataVariable, summaryBlock);
 
            // dataSummary = <type>_getSummary(portValue);
            VuoCompilerType *type = outputPort->getDataVuoType()->getCompiler();
            Value *dataSummaryValue = type->generateSummaryFromValueFunctionCall(module, summaryBlock, dataPointer);
            new StoreInst(dataSummaryValue, dataSummaryVariable, summaryBlock);
 
            BranchInst::Create(sendOutputBlock, summaryBlock);
            currentBlock = sendOutputBlock;
        }
 
        if (shouldSendTelemetry && outputNode != graph->getPublishedInputNode())
        {
            Value *sentDataValue = new LoadInst(sentDataVariable, "", false, currentBlock);
            Value *dataSummaryValue = new LoadInst(dataSummaryVariable, "", false, currentBlock);
 
            Constant *outputPortIdentifierValue = constantsCache->get(outputPort->getIdentifier());
 
            VuoCompilerCodeGenUtilities::generateSendOutputPortsUpdated(module, currentBlock, compositionStateValue, outputPortIdentifierValue,
                                                                        transmittedEventValue, sentDataValue, dataSummaryValue);
        }
    }
 
    // If the output port should transmit an event...
    bool alwaysTransmitsEvent = (dynamic_cast<VuoCompilerTriggerPort *>(outputPort) || ! requiresEvent);
    BasicBlock *transmissionBlock = NULL;
    BasicBlock *noTransmissionBlock = NULL;
    if (alwaysTransmitsEvent)
    {
        transmissionBlock = currentBlock;
    }
    else
    {
        transmissionBlock = BasicBlock::Create(module->getContext(), "transmission", function, NULL);
        noTransmissionBlock = BasicBlock::Create(module->getContext(), "noTransmission", function, NULL);
 
        ConstantInt *zeroValue = ConstantInt::get(static_cast<IntegerType *>(eventValue->getType()), 0);
        ICmpInst *eventValueIsTrue = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, eventValue, zeroValue, "");
        BranchInst::Create(transmissionBlock, noTransmissionBlock, eventValueIsTrue, currentBlock);
    }
 
    // ... then transmit the event and data (if any) to each connected input port.
    for (set<VuoCompilerCable *>::iterator i = outgoingCables.begin(); i != outgoingCables.end(); ++i)
    {
        VuoCompilerCable *cable = *i;
 
        VuoCompilerNode *inputNode = cable->getBase()->getToNode()->getCompiler();
        Value *inputNodeContextValue = inputNode->generateGetContext(module, transmissionBlock, compositionStateValue);
        VuoCompilerInputEventPort *inputPort = static_cast<VuoCompilerInputEventPort *>( cable->getBase()->getToPort()->getCompiler() );
        Value *inputPortContextValue = inputPort->generateGetPortContext(module, transmissionBlock, inputNodeContextValue);
 
        Value *transmittedDataPointer = (cable->carriesData() ? dataPointer : NULL);
 
        cable->generateTransmission(module, transmissionBlock, inputNodeContextValue, inputPortContextValue, transmittedDataPointer, requiresEvent);
 
        if (shouldSendTelemetry && inputNode != graph->getPublishedInputNode())
        {
            // char *inputDataSummary = NULL;
            AllocaInst *inputDataSummaryVariable = new AllocaInst(pointerToCharType, 0, "inputDataSummary", transmissionBlock);
            new StoreInst(ConstantPointerNull::get(pointerToCharType), inputDataSummaryVariable, transmissionBlock);
 
            // bool receivedData = false;
            AllocaInst *receivedDataVariable = new AllocaInst(boolType, 0, "receivedData", transmissionBlock);
            new StoreInst(falseValue, receivedDataVariable, transmissionBlock);
 
            VuoType *inputDataType = inputPort->getDataVuoType();
            if (inputDataType)
            {
                BasicBlock *summaryBlock = BasicBlock::Create(module->getContext(), "inputSummary", function, NULL);
                BasicBlock *sendInputBlock = BasicBlock::Create(module->getContext(), "sendInput", function, NULL);
                BranchInst::Create(summaryBlock, sendInputBlock, shouldSummarizeInput[inputPort], transmissionBlock);
 
                Value *inputDataSummaryValue;
                if (transmittedDataPointer)
                {
                    // receivedData = true;
                    new StoreInst(trueValue, receivedDataVariable, summaryBlock);
 
                    // inputDataSummary = dataSummary;
                    inputDataSummaryValue = new LoadInst(dataSummaryVariable, "", false, summaryBlock);
                }
                else
                {
                    // inputDataSummary = <Type>_getSummary(inputData);
                    Value *inputDataPointer = VuoCompilerCodeGenUtilities::generateGetPortContextDataVariableAsVoidPointer(module, summaryBlock, inputPortContextValue);
                    inputDataSummaryValue = inputDataType->getCompiler()->generateSummaryFromValueFunctionCall(module, summaryBlock, inputDataPointer);
                }
                new StoreInst(inputDataSummaryValue, inputDataSummaryVariable, summaryBlock);
 
                BranchInst::Create(sendInputBlock, summaryBlock);
                transmissionBlock = sendInputBlock;
            }
 
            Value *receivedDataValue = new LoadInst(receivedDataVariable, "", false, transmissionBlock);
            Value *inputDataSummaryValue = new LoadInst(inputDataSummaryVariable, "", false, transmissionBlock);
 
            Constant *inputPortIdentifierValue = constantsCache->get(inputPort->getIdentifier());
 
            VuoCompilerCodeGenUtilities::generateSendInputPortsUpdated(module, transmissionBlock, compositionStateValue, inputPortIdentifierValue,
                                                                       transmittedEventValue, receivedDataValue, inputDataSummaryValue);
 
            if (inputDataType && ! transmittedDataPointer)
            {
                // free(inputDataSummary);
                VuoCompilerCodeGenUtilities::generateFreeCall(module, transmissionBlock, inputDataSummaryValue);
            }
        }
    }
 
    if (alwaysTransmitsEvent)
    {
        currentBlock = transmissionBlock;
    }
    else
    {
        BranchInst::Create(noTransmissionBlock, transmissionBlock);
        currentBlock = noTransmissionBlock;
    }
 
    if (shouldSendTelemetry && dataPointer)
    {
        // free(dataSummary)
        Function *freeFunction = VuoCompilerCodeGenUtilities::getFreeFunction(module);
        LoadInst *dataSummaryValue = new LoadInst(dataSummaryVariable, "", false, currentBlock);
        CallInst::Create(freeFunction, dataSummaryValue, "", currentBlock);
    }
}
 
void VuoCompilerBitcodeGenerator::generateTransmissionFromNode(Function *function, BasicBlock *&currentBlock,
                                                               Value *compositionStateValue, Value *nodeContextValue,
                                                               VuoCompilerNode *node, bool requiresEvent, bool shouldSendTelemetry)
{
    vector<VuoPort *> outputPorts = node->getBase()->getOutputPorts();
    for (vector<VuoPort *>::iterator i = outputPorts.begin(); i != outputPorts.end(); ++i)
    {
        // If the output port is a trigger port, do nothing.
        VuoCompilerOutputEventPort *outputEventPort = dynamic_cast<VuoCompilerOutputEventPort *>((*i)->getCompiler());
        if (! outputEventPort)
            continue;
 
        Value *portContextValue = outputEventPort->generateGetPortContext(module, currentBlock, nodeContextValue);
        Value *outputEventValue = outputEventPort->generateLoadEvent(module, currentBlock, nodeContextValue, portContextValue);
 
        BasicBlock *telemetryBlock = NULL;
        BasicBlock *noTelemetryBlock = NULL;
        if (requiresEvent)
        {
            telemetryBlock = BasicBlock::Create(module->getContext(), "", function, NULL);
            noTelemetryBlock = BasicBlock::Create(module->getContext(), "", function, NULL);
 
            // If the output port isn't transmitting an event, do nothing.
            ConstantInt *zeroValue = ConstantInt::get(static_cast<IntegerType *>(outputEventValue->getType()), 0);
            ICmpInst *eventValueIsTrue = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, outputEventValue, zeroValue, "");
            BranchInst::Create(telemetryBlock, noTelemetryBlock, eventValueIsTrue, currentBlock);
        }
        else
        {
            telemetryBlock = currentBlock;
        }
 
        // Transmit the data through the output port to each connected input port.
        VuoCompilerOutputData *outputData = outputEventPort->getData();
        Value *outputDataPointer = (outputData ?
                                      outputEventPort->generateRetrieveData(module, telemetryBlock, nodeContextValue, portContextValue) :
                                      NULL);
        generateTransmissionFromOutputPort(function, telemetryBlock, compositionStateValue,
                                           node, outputEventPort, outputEventValue, outputDataPointer, requiresEvent, shouldSendTelemetry);
 
        if (requiresEvent)
        {
            BranchInst::Create(noTelemetryBlock, telemetryBlock);
            currentBlock = noTelemetryBlock;
        }
        else
        {
            currentBlock = telemetryBlock;
        }
    }
}
 
void VuoCompilerBitcodeGenerator::generateTelemetryFromPublishedOutputNode(Function *function, BasicBlock *&currentBlock, Value *compositionStateValue,
                                                                           Value *nodeContextValue, VuoCompilerNode *node)
{
    IntegerType *boolType = IntegerType::get(module->getContext(), 1);
    PointerType *pointerToCharType = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
 
    for (auto inputPort : node->getBase()->getInputPorts())
    {
        // If the published output port is for internal use only, do nothing.
        if (inputPort == graph->getGatherPortOnPublishedOutputNode())
            continue;
 
        VuoCompilerInputEventPort *inputEventPort = dynamic_cast<VuoCompilerInputEventPort *>(inputPort->getCompiler());
 
        BasicBlock *telemetryBlock = BasicBlock::Create(module->getContext(), "", function, NULL);
        BasicBlock *noTelemetryBlock = BasicBlock::Create(module->getContext(), "", function, NULL);
 
        // If the published output port isn't transmitting an event, do nothing.
        Value *eventValue = inputEventPort->generateLoadEvent(module, currentBlock, nodeContextValue);
        ConstantInt *zeroValue = ConstantInt::get(static_cast<IntegerType *>(eventValue->getType()), 0);
        ICmpInst *eventValueIsTrue = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, eventValue, zeroValue, "");
        BranchInst::Create(telemetryBlock, noTelemetryBlock, eventValueIsTrue, currentBlock);
 
        VuoCompilerInputData *data = inputEventPort->getData();
        Value *dataPointer = data ? inputEventPort->generateRetrieveData(module, telemetryBlock, nodeContextValue) : NULL;
        Constant *trueValue = ConstantInt::get(boolType, 1);
        Constant *falseValue = ConstantInt::get(boolType, 0);
 
        Value *sentDataValue = NULL;
        Value *dataSummaryValue = NULL;
        if (dataPointer)
        {
            // sentData = true;
            sentDataValue = trueValue;
 
            // dataSummary = <type>_getSummary(portValue);
            VuoCompilerType *type = inputEventPort->getDataVuoType()->getCompiler();
            dataSummaryValue = type->generateSummaryFromValueFunctionCall(module, telemetryBlock, dataPointer);
        }
        else
        {
            // sentData = false;
            sentDataValue = falseValue;
 
            // dataSummary = NULL;
            dataSummaryValue = ConstantPointerNull::get(pointerToCharType);
        }
 
        Constant *portIdentifierValue = constantsCache->get(inputEventPort->getBase()->getClass()->getName());
        VuoCompilerCodeGenUtilities::generateSendPublishedOutputPortsUpdated(module, telemetryBlock, compositionStateValue, portIdentifierValue,
                                                                             sentDataValue, dataSummaryValue);
 
        VuoCompilerCodeGenUtilities::generateFreeCall(module, telemetryBlock, dataSummaryValue);
 
        BranchInst::Create(noTelemetryBlock, telemetryBlock);
        currentBlock = noTelemetryBlock;
    }
}
 
void VuoCompilerBitcodeGenerator::generateDataOnlyTransmissionFromNode(Function *function, BasicBlock *&currentBlock, Value *compositionStateValue,
                                                                       VuoCompilerNode *node, bool shouldWaitForDownstreamNodes,
                                                                       bool shouldUpdateTriggers, bool shouldSendTelemetry)
{
    vector<VuoCompilerNode *> downstreamNodes = graph->getNodesDownstreamViaDataOnlyTransmission(node);
    if (downstreamNodes.empty())
        return;
 
    if (shouldWaitForDownstreamNodes)
    {
        // Claim the nodes downstream via data-only transmission.
        generateLockNodes(module, currentBlock, compositionStateValue, downstreamNodes, nullptr);
    }
 
    // For this node and each node downstream via data-only transmission...
    vector<VuoCompilerNode *> nodesToVisit = downstreamNodes;
    nodesToVisit.insert(nodesToVisit.begin(), node);
    for (VuoCompilerNode *visitedNode : nodesToVisit)
    {
        if (graph->mayTransmitDataOnly(visitedNode))
        {
            Value *nodeContextValue = visitedNode->generateGetContext(module, currentBlock, compositionStateValue);
 
            // Simulate an event having just hit all input ports of the node (necessary due to published input node's doors).
            vector<VuoPort *> inputPorts = visitedNode->getBase()->getInputPorts();
            for (size_t i = VuoNodeClass::unreservedInputPortStartIndex; i < inputPorts.size(); ++i)
            {
                VuoCompilerInputEventPort *inputEventPort = static_cast<VuoCompilerInputEventPort *>(inputPorts[i]->getCompiler());
                inputEventPort->generateStoreEvent(module, currentBlock, nodeContextValue, true);
            }
 
            // Call the node's event function, and send telemetry if needed.
            generateNodeExecution(currentBlock, compositionStateValue, visitedNode, false);
 
            // Transmit data through the node's outgoing cables, and send telemetry for port updates if needed.
            generateTransmissionFromNode(function, currentBlock, compositionStateValue, nodeContextValue, visitedNode, false, shouldSendTelemetry);
 
            // Reset the node's event inputs and outputs.
            VuoCompilerCodeGenUtilities::generateResetNodeContextEvents(module, currentBlock, nodeContextValue);
        }
 
        if (visitedNode != node)
        {
            if (shouldUpdateTriggers)
            {
                // Call the downstream node's trigger update function.
                visitedNode->generateCallbackUpdateFunctionCall(module, currentBlock, compositionStateValue);
            }
 
            if (shouldWaitForDownstreamNodes)
            {
                // Signal the downstream node.
                generateUnlockNodes(module, currentBlock, compositionStateValue, vector<VuoCompilerNode *>(1, visitedNode));
            }
        }
    }
}
 
void VuoCompilerBitcodeGenerator::generateNodeExecution(BasicBlock *block, Value *compositionStateValue, VuoCompilerNode *node,
                                                        bool shouldSendTelemetry)
{
    Value *nodeIdentifierValue = constantsCache->get(node->getIdentifier());
 
    if (shouldSendTelemetry)
    {
        // Send telemetry indicating that the node's execution has started.
        VuoCompilerCodeGenUtilities::generateSendNodeExecutionStarted(module, block, compositionStateValue, nodeIdentifierValue);
    }
 
    // Call the node's event function.
    node->generateEventFunctionCall(module, block, compositionStateValue);
 
    if (shouldSendTelemetry)
    {
        // Send telemetry indicating that the node's execution has finished.
        VuoCompilerCodeGenUtilities::generateSendNodeExecutionFinished(module, block, compositionStateValue, nodeIdentifierValue);
    }
}
 
void VuoCompilerBitcodeGenerator::generateAllocation(void)
{
#ifdef VUO_PRO
    generateAllocation_Pro();
#endif
 
    {
        Constant *value = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
        new GlobalVariable(*module, value->getType(), true, GlobalValue::ExternalLinkage, value, "vuoTopLevelCompositionIdentifier");
    }
}
 
void VuoCompilerBitcodeGenerator::generateSetupFunction(bool isStatefulComposition)
{
    Function *function = VuoCompilerCodeGenUtilities::getSetupFunction(module);
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
 
    Value *topLevelRuntimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, block);
    Value *topLevelCompositionIdentifierValue = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
    Value *topLevelCompositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, topLevelRuntimeStateValue, topLevelCompositionIdentifierValue);
 
    // Top__compositionAddNodeMetadata(compositionState);
 
    Function *compositionCreateAndRegisterMetadataFunction = VuoCompilerCodeGenUtilities::getCompositionAddNodeMetadataFunction(module);
    CallInst::Create(compositionCreateAndRegisterMetadataFunction, topLevelCompositionStateValue, "", block);
 
    // vuoInitContextForTopLevelComposition(compositionState, hasInstanceData, publishedOutputPortCount);
 
    size_t publishedOutputPortCount = composition->getBase()->getPublishedOutputPorts().size();
    VuoCompilerCodeGenUtilities::generateInitContextForTopLevelComposition(module, block, topLevelCompositionStateValue,
                                                                           isStatefulComposition, publishedOutputPortCount);
 
    // Set each published input port to its initial value.
 
    Function *compositionSetPublishedInputPortValueFunction = VuoCompilerCodeGenUtilities::getCompositionSetPublishedInputPortValueFunction(module);
    Value *falseValue = ConstantInt::get(compositionSetPublishedInputPortValueFunction->getFunctionType()->getParamType(3), 0);
 
    for (VuoPublishedPort *publishedInputPort : composition->getBase()->getPublishedInputPorts())
    {
        string name = publishedInputPort->getClass()->getName();
        string initialValue = static_cast<VuoCompilerPublishedPort *>(publishedInputPort->getCompiler())->getInitialValue();
 
        vector<Value *> args;
        args.push_back(topLevelCompositionStateValue);
        args.push_back( constantsCache->get(name) );
        args.push_back( constantsCache->get(initialValue) );
        args.push_back(falseValue);
        CallInst::Create(compositionSetPublishedInputPortValueFunction, args, "", block);
    }
 
    // Top__compositionPerformDataOnlyTransmissions(compositionState);
 
    Function *compositionPerformDataOnlyTransmissionsFunction = VuoCompilerCodeGenUtilities::getCompositionPerformDataOnlyTransmissionsFunction(module);
    CallInst::Create(compositionPerformDataOnlyTransmissionsFunction, topLevelCompositionStateValue, "", block);
 
    // Update the function pointers for all trigger functions in the top-level composition.
 
    for (map<VuoCompilerTriggerPort *, Function *>::iterator i = topLevelTriggerFunctions.begin(); i != topLevelTriggerFunctions.end(); ++i)
    {
        VuoCompilerTriggerPort *trigger = i->first;
        Function *function = i->second;
 
        VuoCompilerNode *node = graph->getNodeForTriggerPort(trigger);
        Value *nodeContextValue = node->generateGetContext(module, block, topLevelCompositionStateValue);
        trigger->generateStoreFunction(module, block, nodeContextValue, function);
    }
 
    // Update the function pointers for all trigger functions in subcompositions.
 
    for (map<string, map<size_t, map<VuoCompilerTriggerDescription *, Function *> > >::iterator i = subcompositionTriggerFunctions.begin(); i != subcompositionTriggerFunctions.end(); ++i)
    {
        string compositionIdentifier = i->first;
 
        for (map<size_t, map<VuoCompilerTriggerDescription *, Function *> >::iterator j = i->second.begin(); j != i->second.end(); ++j)
        {
            size_t nodeIndex = j->first;
 
            for (map<VuoCompilerTriggerDescription *, Function *>::iterator k = j->second.begin(); k != j->second.end(); ++k)
            {
                VuoCompilerTriggerDescription *trigger = k->first;
                Function *function = k->second;
 
                Value *compositionIdentifierValue = constantsCache->get(compositionIdentifier);
                Value *compositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, topLevelRuntimeStateValue, compositionIdentifierValue);
 
                int portContextIndex = trigger->getPortContextIndex();
                Value *nodeContextValue = VuoCompilerCodeGenUtilities::generateGetNodeContext(module, block, compositionStateValue, nodeIndex);
                Value *portContextValue = VuoCompilerCodeGenUtilities::generateGetNodeContextPortContext(module, block, nodeContextValue, portContextIndex);
                VuoCompilerCodeGenUtilities::generateSetPortContextTriggerFunction(module, block, portContextValue, function);
 
                VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, compositionStateValue);
            }
        }
    }
 
    VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, topLevelCompositionStateValue);
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateCleanupFunction(void)
{
    Function *function = VuoCompilerCodeGenUtilities::getCleanupFunction(module);
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
 
    Value *topLevelRuntimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, block);
    Value *topLevelCompositionIdentifierValue = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
    Value *topLevelCompositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, topLevelRuntimeStateValue, topLevelCompositionIdentifierValue);
 
    VuoCompilerCodeGenUtilities::generateFiniContextForTopLevelComposition(module, block, topLevelCompositionStateValue);
 
    VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, topLevelCompositionStateValue);
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateInstanceInitFunction(bool isStatefulComposition)
{
    Function *function = VuoCompilerCodeGenUtilities::getInstanceInitFunction(module);
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
 
    if (isStatefulComposition)
    {
        map<VuoPort *, size_t> indexOfParameter;
        Function *nodeInstanceInitFunction = VuoCompilerCodeGenUtilities::getNodeInstanceInitFunction(module, moduleKey, true,
                                                                                                      VuoCompilerCodeGenUtilities::getCompositionInstanceDataType(module),
                                                                                                      vector<VuoPort *>(),
                                                                                                      indexOfParameter, constantsCache);
 
        Value *topLevelRuntimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, block);
        Value *topLevelCompositionIdentifierValue = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
        Value *topLevelCompositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, topLevelRuntimeStateValue, topLevelCompositionIdentifierValue);
 
        CallInst::Create(nodeInstanceInitFunction, topLevelCompositionStateValue, "", block);
 
        VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, topLevelCompositionStateValue);
    }
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateInstanceFiniFunction(bool isStatefulComposition)
{
    Function *function = VuoCompilerCodeGenUtilities::getInstanceFiniFunction(module);
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
 
    if (isStatefulComposition)
    {
        Function *nodeInstanceFiniFunction = VuoCompilerCodeGenUtilities::getNodeInstanceFiniFunction(module, moduleKey,
                                                                                                      VuoCompilerCodeGenUtilities::getCompositionInstanceDataType(module),
                                                                                                      constantsCache);
 
        Value *topLevelRuntimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, block);
        Value *topLevelCompositionIdentifierValue = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
        Value *topLevelCompositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, topLevelRuntimeStateValue, topLevelCompositionIdentifierValue);
 
        PointerType *instanceDataType = static_cast<PointerType *>( nodeInstanceFiniFunction->getFunctionType()->getParamType(1) );
        ConstantPointerNull *nullInstanceDataValue = ConstantPointerNull::get(instanceDataType);
 
        vector<Value *> args;
        args.push_back(topLevelCompositionStateValue);
        args.push_back(nullInstanceDataValue);
        CallInst::Create(nodeInstanceFiniFunction, args, "", block);
 
        VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, topLevelCompositionStateValue);
    }
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateInstanceTriggerStartFunction(bool isStatefulComposition)
{
    Function *function = VuoCompilerCodeGenUtilities::getInstanceTriggerStartFunction(module);
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
 
    if (isStatefulComposition)
    {
        map<VuoPort *, size_t> indexOfParameter;
        Function *nodeInstanceTriggerStartFunction = VuoCompilerCodeGenUtilities::getNodeInstanceTriggerStartFunction(module, moduleKey,
                                                                                                                      VuoCompilerCodeGenUtilities::getCompositionInstanceDataType(module),
                                                                                                                      vector<VuoPort *>(),
                                                                                                                      indexOfParameter,
                                                                                                                      constantsCache);
 
        Value *topLevelRuntimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, block);
        Value *topLevelCompositionIdentifierValue = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
        Value *topLevelCompositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, topLevelRuntimeStateValue, topLevelCompositionIdentifierValue);
 
        PointerType *instanceDataType = static_cast<PointerType *>( nodeInstanceTriggerStartFunction->getFunctionType()->getParamType(1) );
        ConstantPointerNull *nullInstanceDataValue = ConstantPointerNull::get(instanceDataType);
 
        vector<Value *> args;
        args.push_back(topLevelCompositionStateValue);
        args.push_back(nullInstanceDataValue);
        CallInst::Create(nodeInstanceTriggerStartFunction, args, "", block);
 
        VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, topLevelCompositionStateValue);
    }
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateInstanceTriggerStopFunction(bool isStatefulComposition)
{
    Function *function = VuoCompilerCodeGenUtilities::getInstanceTriggerStopFunction(module);
    BasicBlock *block = BasicBlock::Create(module->getContext(), "", function, NULL);
 
    {
        Function *nodeInstanceTriggerStopFunction = VuoCompilerCodeGenUtilities::getNodeInstanceTriggerStopFunction(module, moduleKey,
                                                                                                                    VuoCompilerCodeGenUtilities::getCompositionInstanceDataType(module),
                                                                                                                    constantsCache);
 
        Value *topLevelRuntimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, block);
        Value *topLevelCompositionIdentifierValue = constantsCache->get(VuoCompilerComposition::topLevelCompositionIdentifier);
        Value *topLevelCompositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, block, topLevelRuntimeStateValue, topLevelCompositionIdentifierValue);
 
        PointerType *instanceDataType = static_cast<PointerType *>( nodeInstanceTriggerStopFunction->getFunctionType()->getParamType(1) );
        ConstantPointerNull *nullInstanceDataValue = ConstantPointerNull::get(instanceDataType);
 
        vector<Value *> args;
        args.push_back(topLevelCompositionStateValue);
        args.push_back(nullInstanceDataValue);
        CallInst::Create(nodeInstanceTriggerStopFunction, args, "", block);
 
        VuoCompilerCodeGenUtilities::generateFreeCompositionState(module, block, topLevelCompositionStateValue);
    }
 
    ReturnInst::Create(module->getContext(), block);
}
 
void VuoCompilerBitcodeGenerator::generateTriggerFunctions(void)
{
    auto isSpinOffTrigger = [] (const string &nodeClassName)
    {
        return (VuoStringUtilities::beginsWith(nodeClassName, "vuo.event.spinOff") ||
                VuoStringUtilities::beginsWith(nodeClassName, "vuo.list.build") ||
                VuoStringUtilities::beginsWith(nodeClassName, "vuo.list.process"));
    };
 
    map<VuoCompilerTriggerPort *, Function *> workerFunctionForTrigger;
    for (VuoCompilerTriggerPort *trigger : graph->getTriggerPorts())
    {
        Function *workerFunction = generateTriggerWorkerFunction(trigger);
        workerFunctionForTrigger[trigger] = workerFunction;
    }
 
    if (isTopLevelComposition)
    {
        for (map<VuoCompilerTriggerPort *, Function *>::iterator i = workerFunctionForTrigger.begin(); i != workerFunctionForTrigger.end(); ++i)
        {
            VuoCompilerTriggerPort *trigger = i->first;
            Function *workerFunction = i->second;
 
            VuoType *dataType = trigger->getDataVuoType();
 
            VuoCompilerNode *node = graph->getNodeForTriggerPort(trigger);
            size_t triggerNodeIndex = node->getIndexInOrderedNodes();
 
            string portIdentifier = trigger->getIdentifier();
 
            int portContextIndex = trigger->getIndexInPortContexts();
 
            bool canDropEvents = (trigger->getBase()->getEventThrottling() == VuoPortClass::EventThrottling_Drop);
 
            bool isPublishedTrigger = (trigger == graph->getPublishedInputTrigger());
 
            bool isSpinOff = isSpinOffTrigger(node->getBase()->getNodeClass()->getClassName());
 
            int minThreadsNeeded, maxThreadsNeeded;
            graph->getWorkerThreadsNeeded(trigger, minThreadsNeeded, maxThreadsNeeded);
 
            int chainCount = (int)graph->getChains()[trigger].size();
 
            Function *function = generateTriggerSchedulerFunction(dataType, VuoCompilerComposition::topLevelCompositionIdentifier, triggerNodeIndex,
                                                                  portIdentifier, portContextIndex, canDropEvents, isPublishedTrigger, isSpinOff,
                                                                  minThreadsNeeded, maxThreadsNeeded, chainCount, workerFunction);
            topLevelTriggerFunctions[trigger] = function;
        }
 
        for (VuoCompilerNode *node : graph->getNodes())
        {
            VuoCompilerNodeClass *nodeClass = node->getBase()->getNodeClass()->getCompiler();
 
            string nodeIdentifier = VuoStringUtilities::buildCompositionIdentifier(VuoCompilerComposition::topLevelCompositionIdentifier,
                                                                                  node->getGraphvizIdentifier());
 
            vector<VuoCompilerTriggerDescription *> triggers = nodeClass->getTriggerDescriptions();
            for (vector<VuoCompilerTriggerDescription *>::iterator j = triggers.begin(); j != triggers.end(); ++j)
            {
                VuoCompilerTriggerDescription *trigger = *j;
 
                size_t triggerNodeIndex = trigger->getNodeIndex();
                string triggerNodeIdentifier = trigger->getNodeIdentifier();
                string portIdentifier = VuoStringUtilities::buildPortIdentifier(triggerNodeIdentifier, trigger->getPortName());
                int portContextIndex = trigger->getPortContextIndex();
                bool canDropEvents = (trigger->getEventThrottling() == VuoPortClass::EventThrottling_Drop);
                VuoType *dataType = trigger->getDataType();
                string subcompositionNodeClassName = trigger->getSubcompositionNodeClassName();
                VuoCompilerNodeClass *subcompositionNodeClass = (subcompositionNodeClassName.empty() ?
                                                                     nodeClass :
                                                                     compiler->getNodeClass(subcompositionNodeClassName));
                string subcompositionNodeIdentifier = trigger->getSubcompositionNodeIdentifier();
                string fullSubcompositionNodeIdentifier = (subcompositionNodeIdentifier.empty() ?
                                                               nodeIdentifier :
                                                               VuoStringUtilities::buildCompositionIdentifier(nodeIdentifier, subcompositionNodeIdentifier));
                bool isPublishedTrigger = (triggerNodeIdentifier == graph->getPublishedInputTriggerNodeIdentifier());
 
                bool isSpinOff = isSpinOffTrigger(trigger->getNodeClassName());
 
                int minThreadsNeeded, maxThreadsNeeded;
                if (isPublishedTrigger)
                    minThreadsNeeded = maxThreadsNeeded = -1;
                else
                    trigger->getWorkerThreadsNeeded(minThreadsNeeded, maxThreadsNeeded);
 
                int chainCount = trigger->getChainCount();
 
                Function *workerFunctionSrc = subcompositionNodeClass->getTriggerWorkerFunction(portIdentifier);
                Function *workerFunction = VuoCompilerModule::declareFunctionInModule(module, workerFunctionSrc);
 
                Function *function = generateTriggerSchedulerFunction(dataType, fullSubcompositionNodeIdentifier, triggerNodeIndex,
                                                                      portIdentifier, portContextIndex, canDropEvents, isPublishedTrigger, isSpinOff,
                                                                      minThreadsNeeded, maxThreadsNeeded, chainCount, workerFunction);
 
                subcompositionTriggerFunctions[fullSubcompositionNodeIdentifier][triggerNodeIndex][trigger] = function;
            }
        }
    }
}
 
Function * VuoCompilerBitcodeGenerator::generateTriggerSchedulerFunction(VuoType *dataType,
                                                                         string compositionIdentifier, size_t nodeIndex,
                                                                         string portIdentifier, int portContextIndex,
                                                                         bool canDropEvents, bool isPublishedInputTrigger, bool isSpinOff,
                                                                         int minThreadsNeeded, int maxThreadsNeeded, int chainCount,
                                                                         Function *workerFunction)
{
    string functionName = VuoStringUtilities::prefixSymbolName(workerFunction->getName().str(),
                                                               VuoStringUtilities::transcodeToIdentifier(compositionIdentifier));
    FunctionType *functionType = VuoCompilerCodeGenUtilities::getFunctionType(module, dataType);
    Function *function = Function::Create(functionType, GlobalValue::InternalLinkage, functionName, module);
 
    if (dataType)
        dataType->getCompiler()->copyFunctionParameterAttributes(function);
 
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, NULL);
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, NULL);
    BasicBlock *scheduleBlock = BasicBlock::Create(module->getContext(), "schedule", function, NULL);
 
    Value *runtimeStateValue = VuoCompilerCodeGenUtilities::generateRuntimeStateValue(module, initialBlock);
    Value *compositionIdentifierValue = constantsCache->get(compositionIdentifier);
 
    Value *compositionStateValue = VuoCompilerCodeGenUtilities::generateCreateCompositionState(module, initialBlock, runtimeStateValue, compositionIdentifierValue);
    compositionStateValue->setName("compositionState");
    VuoCompilerCodeGenUtilities::generateRegisterCall(module, initialBlock, compositionStateValue, VuoCompilerCodeGenUtilities::getFreeFunction(module));
    VuoCompilerCodeGenUtilities::generateRetainCall(module, initialBlock, compositionStateValue);
 
    Value *nodeContextValue = VuoCompilerCodeGenUtilities::generateGetNodeContext(module, initialBlock, compositionStateValue, nodeIndex);
    Value *portContextValue = VuoCompilerCodeGenUtilities::generateGetNodeContextPortContext(module, initialBlock, nodeContextValue, portContextIndex);
 
    if (canDropEvents)
    {
        BasicBlock *checkEventDropBlock = BasicBlock::Create(module->getContext(), "checkEventDrop", function, NULL);
        BranchInst::Create(checkEventDropBlock, initialBlock);
 
        // Do a non-blocking wait on the trigger's semaphore to check if it's already claimed. If so...
        Value *retValue = VuoCompilerTriggerPort::generateNonBlockingWaitForSemaphore(module, checkEventDropBlock, portContextValue);
        Constant *zeroValue = ConstantInt::get(retValue->getType(), 0);
        ICmpInst *isTriggerAvailableValue = new ICmpInst(*checkEventDropBlock, ICmpInst::ICMP_EQ, retValue, zeroValue, "");
        BasicBlock *dropEventBlock = BasicBlock::Create(module->getContext(), "dropEvent", function, NULL);
        BranchInst::Create(scheduleBlock, dropEventBlock, isTriggerAvailableValue, checkEventDropBlock);
 
        // Release the data value.
        if (dataType)
            VuoCompilerTriggerPort::generateDataValueDiscardFromScheduler(module, function, dropEventBlock, dataType);
 
        // Send telemetry that the event has been dropped.
        Constant *portIdentifierValue = constantsCache->get(portIdentifier);
        VuoCompilerCodeGenUtilities::generateSendEventDropped(module, dropEventBlock, compositionStateValue, portIdentifierValue);
 
        VuoCompilerCodeGenUtilities::generateReleaseCall(module, dropEventBlock, compositionStateValue);
 
        BranchInst::Create(finalBlock, dropEventBlock);
    }
    else
    {
        BranchInst::Create(scheduleBlock, initialBlock);
    }
 
    // Enter the trigger's dispatch group for tracking workers scheduled.
    Value *triggerWorkersScheduledValue = VuoCompilerCodeGenUtilities::getTriggerWorkersScheduledValue(module, scheduleBlock, compositionStateValue);
    VuoCompilerCodeGenUtilities::generateEnterDispatchGroup(module, scheduleBlock, triggerWorkersScheduledValue);
 
    Value *eventIdValue;
    if (! isPublishedInputTrigger)
    {
        // Get a unique ID for this event.
        eventIdValue = VuoCompilerCodeGenUtilities::generateGetNextEventId(module, scheduleBlock, compositionStateValue);
 
        // If this trigger fires in response to an input event, and the original event came from the published input trigger,
        // associate the new (spun off) event's ID with the original event.
        if (isSpinOff)
        {
            Value *compositionContextValue = VuoCompilerCodeGenUtilities::generateGetCompositionContext(module, scheduleBlock, compositionStateValue);
            VuoCompilerCodeGenUtilities::generateSpunOffExecutingEvent(module, scheduleBlock, compositionContextValue, eventIdValue);
        }
    }
    else
    {
        // Use the event ID from the parent composition or `firePublishedInputTrigger()`.
        Value *compositionContextValue = VuoCompilerCodeGenUtilities::generateGetCompositionContext(module, scheduleBlock, compositionStateValue);
        eventIdValue = VuoCompilerCodeGenUtilities::generateGetOneExecutingEvent(module, scheduleBlock, compositionContextValue);
    }
 
    // Schedule the trigger's worker function via `vuoScheduleTriggerWorker()`.
    VuoCompilerTriggerPort::generateScheduleWorker(module, function, scheduleBlock,
                                                   compositionStateValue, eventIdValue, portContextValue, dataType,
                                                   minThreadsNeeded, maxThreadsNeeded, chainCount, workerFunction);
    BranchInst::Create(finalBlock, scheduleBlock);
 
    ReturnInst::Create(module->getContext(), finalBlock);
 
    return function;
}
 
Function * VuoCompilerBitcodeGenerator::generateTriggerWorkerFunction(VuoCompilerTriggerPort *trigger)
{
    string functionName = VuoStringUtilities::prefixSymbolName(VuoStringUtilities::transcodeToIdentifier(trigger->getIdentifier()), moduleKey);
    Function *function = trigger->getWorkerFunction(module, functionName, true);
 
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, NULL);
    BasicBlock *triggerBlock = BasicBlock::Create(module->getContext(), "trigger", function, NULL);
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, NULL);
 
    Value *compositionStateValue = trigger->generateCompositionStateValue(module, initialBlock, function);
    Value *compositionContextValue = VuoCompilerCodeGenUtilities::generateGetCompositionContext(module, initialBlock, compositionStateValue);
    Value *eventIdValue = trigger->generateEventIdValue(module, initialBlock, function);
 
    VuoCompilerNode *triggerNode = graph->getNodeForTriggerPort(trigger);
    Value *triggerNodeContextValue = triggerNode->generateGetContext(module, initialBlock, compositionStateValue);
    Value *triggerWorkersScheduledValue = VuoCompilerCodeGenUtilities::getTriggerWorkersScheduledValue(module, initialBlock, compositionStateValue);
    bool canDropEvents = (trigger->getBase()->getEventThrottling() == VuoPortClass::EventThrottling_Drop);
 
    bool isPublishedInputTrigger = (trigger == graph->getPublishedInputTrigger());
    bool isNodeEventForSubcomposition = (! isTopLevelComposition && isPublishedInputTrigger);
 
    if (! isNodeEventForSubcomposition)
    {
        // Check if `isPaused` is true. If so...
        BasicBlock *isPausedBlock = BasicBlock::Create(module->getContext(), "isPaused", function, NULL);
        ICmpInst *isPausedValueIsTrue = VuoCompilerCodeGenUtilities::generateIsPausedComparison(module, initialBlock, compositionStateValue);
        BranchInst::Create(isPausedBlock, triggerBlock, isPausedValueIsTrue, initialBlock);
 
        // Release the data value.
        trigger->generateDataValueDiscardFromWorker(module, isPausedBlock, function);
 
        // Wait for the published output node's semaphore, if not already claimed in `firePublishedInputPortEvent()`.
        VuoCompilerNode *publishedOutputNode = graph->getPublishedOutputNode();
        vector<VuoCompilerNode *> publishedOutputNodeVector(1, publishedOutputNode);
        if (publishedOutputNode && ! isPublishedInputTrigger)
            generateLockNodes(module, isPausedBlock, compositionStateValue, publishedOutputNodeVector);
 
        // Call `vuoSendEventFinished()`.
        VuoCompilerCodeGenUtilities::generateSendEventFinished(module, isPausedBlock, compositionStateValue, eventIdValue);
 
        if (isPublishedInputTrigger)
        {
            // Signal the semaphores claimed in `firePublishedInputPortEvent()`.
            vector<VuoCompilerNode *> triggerWaitNodes = getNodesToWaitOnBeforeTransmission(trigger);
            generateUnlockNodes(module, isPausedBlock, compositionStateValue, triggerWaitNodes);
        }
 
        // Signal the published output node's semaphore.
        if (publishedOutputNode)
            generateUnlockNodes(module, isPausedBlock, compositionStateValue, publishedOutputNodeVector);
 
        if (canDropEvents)
            // Signal the trigger's semaphore for event dropping.
            trigger->generateSignalForSemaphore(module, isPausedBlock, triggerNodeContextValue);
 
        // Leave the trigger's dispatch group for tracking workers scheduled.
        VuoCompilerCodeGenUtilities::generateLeaveDispatchGroup(module, isPausedBlock, triggerWorkersScheduledValue);
 
        // Call `vuoReturnThreadsForTriggerWorker()`.
        VuoCompilerCodeGenUtilities::generateReturnThreadsForTriggerWorker(module, isPausedBlock, eventIdValue, compositionStateValue);
 
        BranchInst::Create(finalBlock, isPausedBlock);
        // Otherwise...
    }
    else
    {
        BranchInst::Create(triggerBlock, initialBlock);
    }
 
    if (isPublishedInputTrigger)
    {
        if (! isNodeEventForSubcomposition)
        {
            // Signal the published output node if it was waited on in `firePublishedInputPortEvent()` just to track event start/finished.
            vector<VuoCompilerNode *> triggerWaitNodes = getNodesToWaitOnBeforeTransmission(trigger);
            VuoCompilerNode *publishedOutputNode = graph->getPublishedOutputNode();
            if (find(triggerWaitNodes.begin(), triggerWaitNodes.end(), publishedOutputNode) == triggerWaitNodes.end())
            {
                vector<VuoCompilerNode *> publishedOutputNodeVector(1, publishedOutputNode);
                generateUnlockNodes(module, triggerBlock, compositionStateValue, publishedOutputNodeVector);
            }
        }
    }
    else
    {
        // Claim the semaphores of all necessary downstream nodes.
        vector<VuoCompilerNode *> triggerWaitNodes = getNodesToWaitOnBeforeTransmission(trigger);
        generateLockNodes(module, triggerBlock, compositionStateValue, triggerWaitNodes, eventIdValue);
 
        // Update the trigger's data value.
        Value *triggerDataValue = trigger->generateDataValueUpdate(module, triggerBlock, function, triggerNodeContextValue);
 
        // Transmit events and data (if any) out of the trigger port, and send telemetry for port updates.
        Value *triggerDataPointer = triggerDataValue ? VuoCompilerCodeGenUtilities::generatePointerToValue(triggerBlock, triggerDataValue) : nullptr;
        generateTransmissionFromOutputPort(function, triggerBlock, compositionStateValue, triggerNode, trigger, NULL, triggerDataPointer);
    }
 
    // If the trigger node isn't downstream of the trigger, signal the trigger node's semaphore.
    vector<VuoCompilerNode *> downstreamNodes = graph->getNodesDownstream(trigger);
    if (find(downstreamNodes.begin(), downstreamNodes.end(), triggerNode) == downstreamNodes.end())
        generateUnlockNodes(module, triggerBlock, compositionStateValue, vector<VuoCompilerNode *>(1, triggerNode));
 
    if (canDropEvents)
        // Signal the trigger's semaphore for event dropping.
        trigger->generateSignalForSemaphore(module, triggerBlock, triggerNodeContextValue);
 
    // Leave the trigger's dispatch group for tracking workers scheduled.
    VuoCompilerCodeGenUtilities::generateLeaveDispatchGroup(module, triggerBlock, triggerWorkersScheduledValue);
 
 
    // Schedule the chain worker function for each chain immediately downstream of the trigger.
 
    map<VuoCompilerChain *, vector<VuoCompilerChain *> > chainsImmediatelyDownstream;
    map<VuoCompilerChain *, vector<VuoCompilerChain *> > chainsImmediatelyUpstream;
    set<VuoCompilerChain *> chainsScheduled;
 
    vector<VuoCompilerChain *> allChains = chainsForTrigger[trigger];
 
    if (! allChains.empty())
    {
        // Organize the chains so it's easy to look up what's downstream/upstream of what.
        for (vector<VuoCompilerChain *>::iterator i = allChains.begin(); i != allChains.end(); ++i)
        {
            VuoCompilerChain *chain = *i;
            VuoCompilerNode *firstNodeInThisChain = chain->getNodes().front();
 
            for (vector<VuoCompilerChain *>::iterator j = allChains.begin(); j != allChains.end(); ++j)
            {
                VuoCompilerChain *otherChain = *j;
 
                if (chain == otherChain)
                    break;  // Any chains after this are downstream.
 
                VuoCompilerNode *lastNodeInOtherChain = otherChain->getNodes().back();
 
                if (graph->mayTransmit(lastNodeInOtherChain, firstNodeInThisChain, trigger))
                {
                    chainsImmediatelyUpstream[chain].push_back(otherChain);
                    chainsImmediatelyDownstream[otherChain].push_back(chain);
                }
            }
        }
 
        // Create the context to pass to the chain workers.
        Value *contextValue = VuoCompilerChain::generateMakeContext(module, triggerBlock, compositionStateValue, eventIdValue);
 
        // Find all chains immediately downstream of the trigger (i.e., chains that have no other chains upstream).
        vector<VuoCompilerChain *> firstChains;
        for (vector<VuoCompilerChain *>::iterator i = allChains.begin(); i != allChains.end(); ++i)
        {
            VuoCompilerChain *chain = *i;
            map<VuoCompilerChain *, vector<VuoCompilerChain *> >::iterator upstreamIter = chainsImmediatelyUpstream.find(chain);
            if (upstreamIter == chainsImmediatelyUpstream.end())
                firstChains.push_back(chain);
        }
 
        // Choose one chain to execute in the trigger worker, to reduce overhead creating/destroying threads.
        VuoCompilerChain *chainToExecute = firstChains.back();
        firstChains.pop_back();
        chainsScheduled.insert(chainToExecute);
        size_t chainIndex = find(allChains.begin(), allChains.end(), chainToExecute) - allChains.begin();
        VuoCompilerCodeGenUtilities::generateRetainCall(module, triggerBlock, contextValue);
 
        // Call `vuoGrantThreadsToChain()` for the chosen chain.
        int minThreadsNeeded, maxThreadsNeeded;
        graph->getWorkerThreadsNeeded(chainToExecute, minThreadsNeeded, maxThreadsNeeded);
        VuoCompilerCodeGenUtilities::generateGrantThreadsToChain(module, triggerBlock, minThreadsNeeded, maxThreadsNeeded,
                                                                 eventIdValue, compositionStateValue, chainIndex);
 
        // Schedule the rest of the chains immediately downstream of the trigger.
        generateAndScheduleChainWorkerFunctions(triggerBlock, compositionStateValue, contextValue, firstChains, trigger,
                                                allChains, chainsImmediatelyDownstream, chainsImmediatelyUpstream, chainsScheduled);
 
        // Execute the chosen chain.
        generateChainExecution(function, triggerBlock, compositionStateValue, contextValue, eventIdValue, chainToExecute, trigger,
                               allChains, chainsImmediatelyDownstream, chainsImmediatelyUpstream, chainsScheduled);
        VuoCompilerCodeGenUtilities::generateReleaseCall(module, triggerBlock, contextValue);
    }
    else
    {
        // Call `vuoReturnThreadsForTriggerWorker()`.
        VuoCompilerCodeGenUtilities::generateReturnThreadsForTriggerWorker(module, triggerBlock, eventIdValue, compositionStateValue);
 
        if (isNodeEventForSubcomposition)
        {
            // Leave the dispatch group waited on by `nodeEvent()`/`nodeInstanceEvent()`.
            Value *subcompositionOutputGroupValue = VuoCompilerCodeGenUtilities::generateGetNodeContextExecutingGroup(module, triggerBlock, compositionContextValue);
            VuoCompilerCodeGenUtilities::generateLeaveDispatchGroup(module, triggerBlock, subcompositionOutputGroupValue);
        }
    }
 
    BranchInst::Create(finalBlock, triggerBlock);
 
    // Free the trigger worker's context.
    trigger->generateFreeContext(module, finalBlock, function);
    VuoCompilerCodeGenUtilities::generateReleaseCall(module, finalBlock, compositionStateValue);
 
    ReturnInst::Create(module->getContext(), finalBlock);
 
    return function;
}
 
void VuoCompilerBitcodeGenerator::generateAndScheduleChainWorkerFunctions(BasicBlock *schedulerBlock,
                                                                          Value *compositionStateValueInScheduler, Value *contextValueInScheduler,
                                                                          const vector<VuoCompilerChain *> &chainsToSchedule, VuoCompilerTriggerPort *trigger,
                                                                          const vector<VuoCompilerChain *> &allChains,
                                                                          const map<VuoCompilerChain *, vector<VuoCompilerChain *> > &chainsImmediatelyDownstream,
                                                                          const map<VuoCompilerChain *, vector<VuoCompilerChain *> > &chainsImmediatelyUpstream,
                                                                          set<VuoCompilerChain *> &chainsScheduled)
{
    // Find the chains in chainsToSchedule that haven't already been scheduled.
    vector<VuoCompilerChain *> uniqueChainsToSchedule;
    for (vector<VuoCompilerChain *>::const_iterator i = chainsToSchedule.begin(); i != chainsToSchedule.end(); ++i)
    {
        VuoCompilerChain *chain = *i;
        if (chainsScheduled.find(chain) == chainsScheduled.end())
        {
            uniqueChainsToSchedule.push_back(chain);
            chainsScheduled.insert(chain);
        }
    }
 
    // Retain the context once for each chain to be scheduled.
    for (vector<VuoCompilerChain *>::const_iterator i = uniqueChainsToSchedule.begin(); i != uniqueChainsToSchedule.end(); ++i)
        VuoCompilerCodeGenUtilities::generateRetainCall(module, schedulerBlock, contextValueInScheduler);
 
    // Schedule each chain.
    for (vector<VuoCompilerChain *>::const_iterator i = uniqueChainsToSchedule.begin(); i != uniqueChainsToSchedule.end(); ++i)
    {
        VuoCompilerChain *chain = *i;
        generateAndScheduleChainWorkerFunction(schedulerBlock, compositionStateValueInScheduler, contextValueInScheduler,
                                               chain, trigger, allChains, chainsImmediatelyDownstream, chainsImmediatelyUpstream,
                                               chainsScheduled);
    }
}
 
void VuoCompilerBitcodeGenerator::generateAndScheduleChainWorkerFunction(BasicBlock *schedulerBlock,
                                                                         Value *compositionStateValueInScheduler, Value *contextValueInScheduler,
                                                                         VuoCompilerChain *chain, VuoCompilerTriggerPort *trigger,
                                                                         const vector<VuoCompilerChain *> &allChains,
                                                                         const map<VuoCompilerChain *, vector<VuoCompilerChain *> > &chainsImmediatelyDownstream,
                                                                         const map<VuoCompilerChain *, vector<VuoCompilerChain *> > &chainsImmediatelyUpstream,
                                                                         set<VuoCompilerChain *> &chainsScheduled)
{
    int minThreadsNeeded, maxThreadsNeeded;
    graph->getWorkerThreadsNeeded(chain, minThreadsNeeded, maxThreadsNeeded);
 
    size_t chainIndex = find(allChains.begin(), allChains.end(), chain) - allChains.begin();
 
    vector<VuoCompilerChain *> upstreamChains;
    map<VuoCompilerChain *, vector<VuoCompilerChain *> >::const_iterator upstreamChainsIter = chainsImmediatelyUpstream.find(chain);
    if (upstreamChainsIter != chainsImmediatelyUpstream.end())
        upstreamChains = upstreamChainsIter->second;
 
    vector<size_t> upstreamChainIndices;
    for (vector<VuoCompilerChain *>::iterator i = upstreamChains.begin(); i != upstreamChains.end(); ++i)
        upstreamChainIndices.push_back( find(allChains.begin(), allChains.end(), *i) - allChains.begin() );
 
    // Call `vuoScheduleChainWorker` for the worker function implemented below.
    Function *chainWorker = chain->generateScheduleWorker(module, schedulerBlock, compositionStateValueInScheduler, contextValueInScheduler,
                                                          trigger->getIdentifier(), minThreadsNeeded, maxThreadsNeeded, chainIndex,
                                                          upstreamChainIndices);
 
    BasicBlock *chainBlock = BasicBlock::Create(module->getContext(), "", chainWorker, 0);
    Value *contextValueInChainWorker = chainWorker->arg_begin();
    Value *compositionStateValueInChainWorker = chain->generateCompositionStateValue(module, chainBlock, contextValueInChainWorker);
    Value *eventIdValue = chain->generateEventIdValue(module, chainBlock, contextValueInChainWorker);
 
    // Execute the chain.
    generateChainExecution(chainWorker, chainBlock, compositionStateValueInChainWorker, contextValueInChainWorker, eventIdValue, chain, trigger,
                           allChains, chainsImmediatelyDownstream, chainsImmediatelyUpstream, chainsScheduled);
 
    // Release the chain worker's context.
    VuoCompilerCodeGenUtilities::generateReleaseCall(module, chainBlock, contextValueInChainWorker);
 
    ReturnInst::Create(module->getContext(), chainBlock);
}
 
void VuoCompilerBitcodeGenerator::generateChainExecution(Function *function, BasicBlock *&block,
                                                         Value *compositionStateValue, Value *contextValue,
                                                         Value *eventIdValue, VuoCompilerChain *chain, VuoCompilerTriggerPort *trigger,
                                                         const vector<VuoCompilerChain *> &allChains,
                                                         const map<VuoCompilerChain *, vector<VuoCompilerChain *> > &chainsImmediatelyDownstream,
                                                         const map<VuoCompilerChain *, vector<VuoCompilerChain *> > &chainsImmediatelyUpstream,
                                                         set<VuoCompilerChain *> &chainsScheduled)
{
    size_t chainIndex = find(allChains.begin(), allChains.end(), chain) - allChains.begin();
    Value *chainIndexValue = ConstantInt::get(eventIdValue->getType(), chainIndex);
 
    // For each node in the chain...
    vector<VuoCompilerNode *> chainNodes = chain->getNodes();
    for (vector<VuoCompilerNode *>::iterator i = chainNodes.begin(); i != chainNodes.end(); ++i)
    {
        VuoCompilerNode *node = *i;
 
        Function *nodeExecutionFunction = executionFunctionForNode[node];
        if (! nodeExecutionFunction)
        {
            nodeExecutionFunction = generateNodeExecutionFunction(module, node);
            executionFunctionForNode[node] = nodeExecutionFunction;
        }
 
        Function *nodeTransmissionFunction = transmissionFunctionForNode[node];
        if (! nodeTransmissionFunction)
        {
            nodeTransmissionFunction = generateNodeTransmissionFunction(module, node);
            transmissionFunctionForNode[node] = nodeTransmissionFunction;
        }
 
        // If the event hit the node, call its event function and send telemetry.
        vector<Value *> nodeExecutionArgs;
        nodeExecutionArgs.push_back(compositionStateValue);
        nodeExecutionArgs.push_back(eventIdValue);
        nodeExecutionArgs.push_back(chainIndexValue);
        CallInst *isHitValue = CallInst::Create(nodeExecutionFunction, nodeExecutionArgs, "", block);
 
        // Whether or not the event hit the node, wait on any necessary downstream nodes.
        if (! (graph->isRepeatedInFeedbackLoop(node, trigger) && chain->isLastNodeInLoop()))
        {
            vector<VuoCompilerNode *> outputNodes = getNodesToWaitOnBeforeTransmission(trigger, node);
            generateLockNodes(module, block, compositionStateValue, outputNodes, eventIdValue);
        }
 
        // If the event hit the node, transmit events and data through its output cables and send telemetry.
        vector<Value *> nodeTransmissionArgs;
        nodeTransmissionArgs.push_back(compositionStateValue);
        nodeTransmissionArgs.push_back(isHitValue);
        CallInst::Create(nodeTransmissionFunction, nodeTransmissionArgs, "", block);
 
        // Whether or not the event hit the node, if this was the last time this event could reach the node,
        // signal the node's semaphore.
        if (! (graph->isRepeatedInFeedbackLoop(node, trigger) && ! chain->isLastNodeInLoop()))
        {
            // Special case: If this is the published output node in a subcomposition,
            // the node's semaphore is signaled in the node's execution function or the subcomposition's nodeEvent()/nodeInstanceEvent().
            if (! (! isTopLevelComposition && node == graph->getPublishedOutputNode()))
                generateUnlockNodes(module, block, compositionStateValue, vector<VuoCompilerNode *>(1, node));
        }
    }
 
    // Schedule any chains immediately downstream, if this chain is the one responsible for doing so.
    vector<VuoCompilerChain *> downstreamChains;
    map<VuoCompilerChain *, vector<VuoCompilerChain *> >::const_iterator downstreamChainsIter = chainsImmediatelyDownstream.find(chain);
    if (downstreamChainsIter != chainsImmediatelyDownstream.end())
        downstreamChains = downstreamChainsIter->second;
    if (! downstreamChains.empty())
    {
        vector<size_t> downstreamChainIndices;
        for (vector<VuoCompilerChain *>::iterator i = downstreamChains.begin(); i != downstreamChains.end(); ++i)
            downstreamChainIndices.push_back( find(allChains.begin(), allChains.end(), *i) - allChains.begin() );
 
        vector<VuoCompilerChain *> nextChains;
        for (vector<VuoCompilerChain *>::iterator i = downstreamChains.begin(); i != downstreamChains.end(); ++i)
        {
            VuoCompilerChain *downstreamChain = *i;
            nextChains.push_back(downstreamChain);
        }
 
        generateAndScheduleChainWorkerFunctions(block, compositionStateValue, contextValue, nextChains, trigger, allChains,
                                                chainsImmediatelyDownstream, chainsImmediatelyUpstream, chainsScheduled);
    }
 
    // Return the threads used by this chain to the thread pool.
    VuoCompilerCodeGenUtilities::generateReturnThreadsForChainWorker(module, block, eventIdValue, compositionStateValue, chainIndexValue);
}
 
Function * VuoCompilerBitcodeGenerator::generateNodeExecutionFunction(Module *module, VuoCompilerNode *node)
{
    string functionName = node->getIdentifier() + "__execute";
    PointerType *pointerToCompositionStateType = PointerType::get(VuoCompilerCodeGenUtilities::getCompositionStateType(module), 0);
    Type *boolType = IntegerType::get(module->getContext(), 1);
    Type *eventIdType = VuoCompilerCodeGenUtilities::generateNoEventIdConstant(module)->getType();
    vector<Type *> params;
    params.push_back(pointerToCompositionStateType);
    params.push_back(eventIdType);
    params.push_back(eventIdType);
    FunctionType *functionType = FunctionType::get(boolType, params, false);
    Function *function = Function::Create(functionType, GlobalValue::InternalLinkage, functionName, module);
 
    Function::arg_iterator args = function->arg_begin();
    Value *compositionStateValue = args++;
    compositionStateValue->setName("compositionState");
    Value *eventIdValue = args++;
    eventIdValue->setName("eventId");
    Value *chainIndexValue = args++;
    chainIndexValue->setName("chainIndex");
 
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, NULL);
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, NULL);
 
    Value *nodeContextValue = node->generateGetContext(module, initialBlock, compositionStateValue);
    Value *isHitValue = VuoCompilerCodeGenUtilities::generateEventHitAnyPort(module, initialBlock, nodeContextValue);
 
    if (node == graph->getPublishedOutputNode())
    {
        if (isTopLevelComposition)
        {
            VuoCompilerCodeGenUtilities::generateSendEventFinished(module, initialBlock, compositionStateValue, eventIdValue);
 
            BranchInst::Create(finalBlock, initialBlock);
        }
        else
        {
            // Call the trigger functions for any published trigger ports that the event has hit.
 
            BasicBlock *currBlock = initialBlock;
 
            Value *compositionContextValue = VuoCompilerCodeGenUtilities::generateGetCompositionContext(module, currBlock, compositionStateValue);
 
            vector<VuoPublishedPort *> publishedInputPorts = composition->getBase()->getPublishedInputPorts();
            vector<VuoPublishedPort *> publishedOutputPorts = composition->getBase()->getPublishedOutputPorts();
 
            set<string> publishedOutputTriggerNames = graph->getPublishedOutputTriggers();
 
            for (size_t publishedPortIndex = 0; publishedPortIndex < publishedOutputPorts.size(); ++publishedPortIndex)
            {
                VuoPort *port = graph->getInputPortOnPublishedOutputNode(publishedPortIndex);
                VuoCompilerInputEventPort *eventPort = static_cast<VuoCompilerInputEventPort *>( port->getCompiler() );
 
                Value *portContextValue = eventPort->generateGetPortContext(module, currBlock, nodeContextValue);
                Value *isPortHitValue = VuoCompilerCodeGenUtilities::generateGetPortContextEvent(module, currBlock, portContextValue);
 
                if (publishedOutputTriggerNames.find( port->getClass()->getName() ) != publishedOutputTriggerNames.end())
                {
                    BasicBlock *triggerBlock = BasicBlock::Create(module->getContext(), "trigger", function, NULL);
                    BasicBlock *nextBlock = BasicBlock::Create(module->getContext(), "next", function, NULL);
                    Constant *falseValue = ConstantInt::get(isPortHitValue->getType(), 0);
                    ICmpInst *isPortHitIsTrue = new ICmpInst(*currBlock, ICmpInst::ICMP_NE, isPortHitValue, falseValue);
                    BranchInst::Create(triggerBlock, nextBlock, isPortHitIsTrue, currBlock);
 
                    VuoType *dataType = eventPort->getDataVuoType();
 
                    FunctionType *triggerFunctionType = VuoCompilerCodeGenUtilities::getFunctionType(module, dataType);
 
                    vector<Value *> args;
                    if (dataType)
                    {
                        Value *dataPointer = eventPort->generateRetrieveData(module, triggerBlock, nodeContextValue);
                        args = dataType->getCompiler()->convertPortDataToArgs(module, triggerBlock, dataPointer, triggerFunctionType, 0, false);
                    }
 
                    int indexInSubcompositionPorts = VuoNodeClass::unreservedInputPortStartIndex + publishedInputPorts.size() +
                                                     VuoNodeClass::unreservedOutputPortStartIndex + publishedPortIndex;
 
                    Value *triggerPortContextValue = VuoCompilerCodeGenUtilities::generateGetNodeContextPortContext(module, triggerBlock, compositionContextValue, indexInSubcompositionPorts);
                    Value *triggerFunction = VuoCompilerCodeGenUtilities::generateGetPortContextTriggerFunction(module, triggerBlock, triggerPortContextValue, triggerFunctionType);
 
                    CallInst *triggerFunctionCall = CallInst::Create(triggerFunction, args, "", triggerBlock);
                    if (dataType)
                        dataType->getCompiler()->copyFunctionParameterAttributes(module, triggerFunctionCall);
 
                    BranchInst::Create(nextBlock, triggerBlock);
 
                    currBlock = nextBlock;
                }
                else
                {
                    VuoCompilerCodeGenUtilities::generateSetNodeContextOutputEvent(module, currBlock, compositionContextValue, publishedPortIndex, isPortHitValue);
                }
            }
 
            // If this event (which may or may not have actually hit the published output node) is from
            // nodeEvent()/nodeInstanceEvent() or an event spun off of it, and is the final one to complete, then...
 
            Value *subcompositionFinishedValue = VuoCompilerCodeGenUtilities::generateFinishedExecutingEvent(module, currBlock, compositionContextValue, eventIdValue);
            ConstantInt *falseValue = ConstantInt::get(static_cast<IntegerType *>(subcompositionFinishedValue->getType()), 0);
            ICmpInst *subcompositionFinishedIsTrue = new ICmpInst(*currBlock, ICmpInst::ICMP_NE, subcompositionFinishedValue, falseValue, "");
            BasicBlock *leaveBlock = BasicBlock::Create(module->getContext(), "leave", function, NULL);
            BasicBlock *signalBlock = BasicBlock::Create(module->getContext(), "signal", function, NULL);
            BranchInst::Create(leaveBlock, signalBlock, subcompositionFinishedIsTrue, currBlock);
 
            // Leave the dispatch group waited on by nodeEvent()/nodeInstanceEvent().
 
            Value *subcompositionOutputGroupValue = VuoCompilerCodeGenUtilities::generateGetNodeContextExecutingGroup(module, leaveBlock, compositionContextValue);
            VuoCompilerCodeGenUtilities::generateLeaveDispatchGroup(module, leaveBlock, subcompositionOutputGroupValue);
            BranchInst::Create(finalBlock, leaveBlock);
 
            // Otherwise, signal the published output node's semaphore so that the remaining events can claim it.
            // (For the final event, the published output node's semaphore is signaled in nodeEvent()/nodeInstanceEvent().)
 
            generateUnlockNodes(module, signalBlock, compositionStateValue, vector<VuoCompilerNode *>(1, node));
            BranchInst::Create(finalBlock, signalBlock);
        }
    }
    else
    {
        // If the node received an event, then...
        BasicBlock *executeBlock = BasicBlock::Create(module->getContext(), "execute", function, NULL);
        BranchInst::Create(executeBlock, finalBlock, isHitValue, initialBlock);
 
        if (node->getBase()->getNodeClass()->getCompiler()->isSubcomposition())
        {
            // Pass the event ID to the subcomposition.
            VuoCompilerCodeGenUtilities::generateStartedExecutingEvent(module, executeBlock, nodeContextValue, eventIdValue);
 
            // Pass the chain's reserved threads to the subcomposition.
            Value *compositionIdentifierValue = VuoCompilerCodeGenUtilities::generateGetCompositionStateCompositionIdentifier(module, executeBlock, compositionStateValue);
            Value *subcompositionIdentifierValue = node->generateSubcompositionIdentifierValue(module, executeBlock, compositionIdentifierValue);
            VuoCompilerCodeGenUtilities::generateGrantThreadsToSubcomposition(module, executeBlock,
                                                                              eventIdValue, compositionStateValue, chainIndexValue,
                                                                              subcompositionIdentifierValue);
            VuoCompilerCodeGenUtilities::generateFreeCall(module, executeBlock, subcompositionIdentifierValue);
        }
 
        // Call the node's event function, and send telemetry that the node's execution has started and finished.
        bool shouldSendTelemetry = (node != graph->getPublishedInputNode());
        generateNodeExecution(executeBlock, compositionStateValue, node, shouldSendTelemetry);
        BranchInst::Create(finalBlock, executeBlock);
    }
 
    ReturnInst::Create(module->getContext(), isHitValue, finalBlock);
 
    return function;
}
 
Function * VuoCompilerBitcodeGenerator::generateNodeTransmissionFunction(Module *module, VuoCompilerNode *node)
{
    string functionName = node->getIdentifier() + "__transmit";
    PointerType *pointerToCompositionStateType = PointerType::get(VuoCompilerCodeGenUtilities::getCompositionStateType(module), 0);
    Type *boolType = IntegerType::get(module->getContext(), 1);
    vector<Type *> params;
    params.push_back(pointerToCompositionStateType);
    params.push_back(boolType);
    FunctionType *functionType = FunctionType::get(Type::getVoidTy(module->getContext()), params, false);
    Function *function = Function::Create(functionType, GlobalValue::InternalLinkage, functionName, module);
 
    Function::arg_iterator args = function->arg_begin();
    Value *compositionStateValue = args++;
    compositionStateValue->setName("compositionState");
    Value *isHitValue = args++;
    isHitValue->setName("isHit");
 
    BasicBlock *initialBlock = BasicBlock::Create(module->getContext(), "initial", function, NULL);
    BasicBlock *transmitBlock = BasicBlock::Create(module->getContext(), "transmit", function, NULL);
    BasicBlock *finalBlock = BasicBlock::Create(module->getContext(), "final", function, NULL);
 
    // If the node received an event, then...
    BranchInst::Create(transmitBlock, finalBlock, isHitValue, initialBlock);
 
    Value *nodeContextValue = node->generateGetContext(module, transmitBlock, compositionStateValue);
 
    if (node == graph->getPublishedOutputNode())
    {
        if (isTopLevelComposition)
            generateTelemetryFromPublishedOutputNode(function, transmitBlock, compositionStateValue, nodeContextValue, node);
    }
    else
    {
        // Transmit events and data through the node's outgoing cables, and send telemetry for port updates.
        generateTransmissionFromNode(function, transmitBlock, compositionStateValue, nodeContextValue, node);
    }
 
    // Reset the node's event inputs and outputs.
    VuoCompilerCodeGenUtilities::generateResetNodeContextEvents(module, transmitBlock, nodeContextValue);
 
    BranchInst::Create(finalBlock, transmitBlock);
    ReturnInst::Create(module->getContext(), finalBlock);
 
    return function;
}