VuoCompilerBitcodeGenerator.hh

Go to the documentation of this file.

 
#pragma once
 
#include "VuoCompilerConstantStringCache.hh"
 
class VuoCompiler;
class VuoCompilerChain;
class VuoCompilerComposition;
class VuoCompilerGraph;
class VuoCompilerNode;
class VuoCompilerPort;
class VuoCompilerTriggerDescription;
class VuoCompilerTriggerPort;
class VuoCompilerType;
class VuoPort;
class VuoType;
 
class VuoCompilerBitcodeGenerator
{
private:
    VuoCompilerComposition *composition;
    VuoCompiler *compiler;
    VuoCompilerGraph *graph;
 
    bool isTopLevelComposition;
 
    string moduleKey;
 
    vector<VuoPort *> modelInputPorts;
 
    vector<VuoPort *> modelOutputPorts;
 
    map<VuoCompilerTriggerPort *, vector<VuoCompilerChain *> > chainsForTrigger;
 
    map<VuoCompilerTriggerPort *, vector<VuoCompilerNode *> > downstreamNodesForTrigger;
 
    vector<VuoCompilerNode *> orderedNodes;
 
    vector<VuoCompilerType *> orderedTypes;
 
    set<string> dependencies;
 
    Module *module;
 
    VuoCompilerConstantStringCache constantStrings;
 
    map<VuoCompilerNode *, Function *> executionFunctionForNode;
 
    map<VuoCompilerNode *, Function *> transmissionFunctionForNode;
 
    map<VuoCompilerTriggerPort *, Function *> topLevelTriggerFunctions;
 
    map<string, map<size_t, map<VuoCompilerTriggerDescription *, Function *> > > subcompositionTriggerFunctions;
 
    bool debugMode;
 
    VuoCompilerBitcodeGenerator(VuoCompilerComposition *composition, bool isTopLevelComposition, string moduleKey, VuoCompiler *compiler);
    void makeOrderedNodes(void);
    void sortNodes(vector<VuoCompilerNode *> &nodes);
    vector<VuoCompilerNode *> getNodesToWaitOnBeforeTransmission(VuoCompilerTriggerPort *trigger);
    vector<VuoCompilerNode *> getNodesToWaitOnBeforeTransmission(VuoCompilerTriggerPort *trigger, VuoCompilerNode *node);
    void makeOrderedTypes(void);
    void makePortContextInfo(void);
    void makeSubcompositionModelPorts(void);
    void makeDependencies(void);
    void generateShouldShowSplashWindowFunction(bool shouldShow);
    void generateCompositionMetadata(void);
    void generateCompositionAddNodeMetadataFunction(void);
    void generateCompositionCreateContextForNodeFunction(void);
    void generateCompositionPerformDataOnlyTransmissionsFunction(void);
    void generateCompositionReleasePortDataFunction(void);
    void generateSetInputDataFromNodeFunctionArguments(Function *function, BasicBlock *&block, Value *compositionStateValue, map<VuoPort *, size_t> indexOfParameter, map<VuoPort *, size_t> indexOfEventParameter, bool shouldWaitForDataOnlyDownstreamNodes, bool shouldUpdateTriggers, bool shouldSendTelemetry);
    void generateNodeEventFunction(bool isStatefulComposition);
    void generateNodeInstanceInitFunction(void);
    void generateNodeInstanceFiniFunction(void);
    void generateNodeInstanceTriggerStartFunction(void);
    void generateNodeInstanceTriggerStopFunction(void);
    void generateNodeInstanceTriggerUpdateFunction(void);
    Value * generateWaitForNodes(Module *module, Function *function, BasicBlock *&block, Value *compositionStateValue, vector<VuoCompilerNode *> nodes, Value *eventIdValue = NULL, bool shouldBlock = true);
    void generateCompositionWaitForNodeFunction(void);
    void generateSignalForNodes(Module *module, BasicBlock *block, Value *compositionStateValue, vector<VuoCompilerNode *> nodes);
    void generateCompositionGetPortValueFunction(void);
    void generateCompositionSetPortValueFunction(void);
    void generateSetInputPortValueFunction(void);
    void generateCompositionFireTriggerPortEventFunction(void);
    void generateGetPublishedPortCountFunction(bool input);
    void generateGetPublishedPortNamesFunction(bool input);
    void generateGetPublishedPortTypesFunction(bool input);
    void generateGetPublishedPortDetailsFunction(bool input);
    void generateFunctionReturningStringArray(string functionName, vector<string> stringValues);
    void generateFirePublishedInputPortEventFunction(void);
    void generateGetPublishedPortValueFunction(bool input);
    void generateCompositionSetPublishedInputPortValueFunction(void);
    void generateSetPublishedInputPortValueFunction(void);
    void generateTransmissionFromOutputPort(Function *function, BasicBlock *&currentBlock, Value *compositionStateValue, VuoCompilerPort *outputPort, Value *eventValue, Value *dataValue, bool requiresEvent = true, bool shouldSendTelemetry = true);
    void generateTransmissionFromNode(Function *function, BasicBlock *&currentBlock, Value *compositionStateValue, Value *nodeContextValue, VuoCompilerNode *node, bool requiresEvent = true, bool shouldSendTelemetry = true);
    void generateTelemetryFromPublishedOutputNode(Function *function, BasicBlock *&currentBlock, Value *compositionStateValue, Value *nodeContextValue, VuoCompilerNode *node);
    void generateDataOnlyTransmissionFromNode(Function *function, BasicBlock *&currentBlock, Value *compositionStateValue, VuoCompilerNode *node, bool shouldWaitForDownstreamNodes, bool shouldUpdateTriggers, bool shouldSendTelemetry);
    void generateNodeExecution(Function *function, BasicBlock *&currentBlock, Value *compositionStateValue, VuoCompilerNode *node, bool shouldSendTelemetry = true);
    void generateAllocation(void);
    void generateSetupFunction(bool isStatefulComposition);
    void generateCleanupFunction(void);
    void generateInstanceInitFunction(bool isStatefulComposition);
    void generateInstanceFiniFunction(bool isStatefulComposition);
    void generateInstanceTriggerStartFunction(bool isStatefulComposition);
    void generateInstanceTriggerStopFunction(bool isStatefulComposition);
    void generateTriggerFunctions(void);
    Function * 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);
    Function * generateTriggerWorkerFunction(VuoCompilerTriggerPort *trigger);
    void 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);
    void 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);
    void 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);
    Function * generateNodeExecutionFunction(Module *module, VuoCompilerNode *node);
    Function * generateNodeTransmissionFunction(Module *module, VuoCompilerNode *node);
 
    friend class TestVuoCompilerBitcodeGenerator;
    friend class TestVuoCompilerGraphExecution;
    friend class TestControlAndTelemetry;
    friend class TestNodeExecutionOrderRunnerDelegate;
 
public:
    static VuoCompilerBitcodeGenerator * newBitcodeGeneratorFromComposition(VuoCompilerComposition *composition,
                                                                            bool isTopLevelComposition,
                                                                            string moduleKey, VuoCompiler *compiler);
    ~VuoCompilerBitcodeGenerator(void);
    Module * generateBitcode(void);
    void setDebugMode(bool debugMode);
 
#ifdef VUO_PRO
#include "pro/VuoCompilerBitcodeGenerator_Pro.hh"
#endif
};