VuoCompilerGraph.hh

Go to the documentation of this file.

 
#pragma once
 
class VuoCompiler;
class VuoCompilerCable;
class VuoCompilerChain;
class VuoCompilerComposition;
class VuoCompilerInputEventPort;
class VuoCompilerIssues;
class VuoCompilerNode;
class VuoCompilerNodeClass;
class VuoCompilerPort;
class VuoCompilerTriggerPort;
class VuoCable;
class VuoNode;
class VuoPort;
class VuoPublishedPort;
 
#include "VuoPortClass.hh"
 
class VuoCompilerGraph
{
public:
    VuoCompilerGraph(VuoCompilerComposition *composition, VuoCompiler *compiler = nullptr, set<VuoCompilerCable *> potentialCables = set<VuoCompilerCable *>());
    ~VuoCompilerGraph(void);
    bool mayTransmit(VuoCompilerNode *fromNode, VuoCompilerNode *toNode, VuoCompilerTriggerPort *trigger);
    bool mayTransmitDataOnly(VuoCompilerNode *node);
    vector<VuoCompilerTriggerPort *> getTriggerPorts(void);
    VuoCompilerNode * getNodeForTriggerPort(VuoCompilerTriggerPort *trigger);
    set<VuoCompilerNode *> getNodes(void);
    VuoCompilerNode * getPublishedInputNode(void);
    VuoCompilerNode * getPublishedOutputNode(void);
    VuoCompilerTriggerPort * getPublishedInputTrigger(void);
    VuoPort * getInputPortOnPublishedInputNode(size_t publishedInputPortIndex);
    VuoPort * getInputPortOnPublishedOutputNode(size_t publishedOutputPortIndex);
    VuoCompilerTriggerPort * getManuallyFirableTrigger(void);
    map<VuoCompilerTriggerPort *, vector<VuoCompilerChain *> > getChains(void);
    vector<VuoCompilerNode *> getNodesImmediatelyDownstream(VuoCompilerTriggerPort *trigger);
    vector<VuoCompilerNode *> getNodesImmediatelyDownstream(VuoCompilerNode *node, VuoCompilerTriggerPort *trigger);
    vector<VuoCompilerNode *> getNodesDownstream(VuoCompilerTriggerPort *trigger);
    vector<VuoCompilerNode *> getNodesDownstream(VuoCompilerNode *node, VuoCompilerTriggerPort *trigger);
    vector<VuoCompilerNode *> getNodesDownstreamViaDataOnlyTransmission(VuoCompilerNode *node);
    set<VuoCompilerCable *> getOutgoingCables(VuoCompilerPort *outputPort);
    set<VuoCompilerNode *> getSourceNodesOfDataOnlyTransmission(void);
    void getWorkerThreadsNeeded(VuoCompilerChain *chain, int &minThreadsNeeded, int &maxThreadsNeeded);
    void getWorkerThreadsNeeded(VuoCompilerTriggerPort *trigger, int &minThreadsNeeded, int &maxThreadsNeeded);
    VuoCompilerTriggerPort * findNearestUpstreamTrigger(VuoCompilerNode *node);
    VuoPortClass::EventBlocking getPublishedInputEventBlocking(size_t publishedInputPortIndex);
    set<string> getPublishedOutputTriggers(void);
    set<string> getPublishedOutputTriggersDownstream(VuoCompilerTriggerPort *trigger);
    set<string> getPublishedOutputPortsDownstream(VuoCompilerTriggerPort *trigger);
    bool mayEventsReachPublishedOutputPorts(void);
    bool isRepeatedInFeedbackLoop(VuoCompilerNode *node, VuoCompilerTriggerPort *trigger);
    bool hasGatherDownstream(VuoCompilerNode *node, VuoCompilerTriggerPort *trigger);
    bool hasScatterPartiallyOverlappedByAnotherTrigger(VuoCompilerTriggerPort *trigger);
    bool hasScatterPartiallyOverlappedByAnotherTrigger(VuoCompilerNode *node, VuoCompilerTriggerPort *trigger);
    bool hasOverlapWithSpinOff(VuoCompilerTriggerPort *trigger);
    void checkForInfiniteFeedback(VuoCompilerIssues *issues);
    void checkForDeadlockedFeedback(VuoCompilerIssues *issues);
    static long getHash(VuoCompilerComposition *composition);
    static string getPublishedInputTriggerNodeIdentifier(void);
    static string getManuallyFirableTriggerNodeIdentifier(void);
 
private:
    class Vertex
    {
    public:
        VuoCompilerTriggerPort *fromTrigger;
        VuoCompilerNode *fromNode;
        VuoCompilerNode *toNode;
        set<VuoCompilerCable *> cableBundle;
        Vertex(VuoCompilerTriggerPort *fromTrigger, VuoCompilerNode *toNode);
        Vertex(VuoCompilerNode *fromNode, VuoCompilerNode *toNode);
        Vertex(void);
        string toString(void) const;
    };
 
    class Edge
    {
    public:
        Vertex fromVertex;
        Vertex toVertex;
        Edge(const Vertex &fromVertex, const Vertex &toVertex);
        Edge(void);
        string toString(void) const;
    };
 
    friend bool operator==(const Vertex &lhs, const Vertex &rhs);
    friend bool operator!=(const Vertex &lhs, const Vertex &rhs);
    friend bool operator<(const Vertex &lhs, const Vertex &rhs);
    friend bool operator<(const Edge &lhs, const Edge &rhs);
 
    map<VuoCompilerTriggerPort *, vector<Vertex> > vertices;
 
    map<VuoCompilerTriggerPort *, set<Edge> > edges;
 
    map<VuoCompilerTriggerPort *, map<Vertex, set<Vertex> > > downstreamVertices;
 
    map<VuoCompilerTriggerPort *, set<Vertex> > repeatedVertices;
 
    vector<VuoCompilerTriggerPort *> triggers;
 
    map<VuoCompilerTriggerPort *, VuoCompilerNode *> nodeForTrigger;
 
    VuoCompilerTriggerPort *publishedInputTrigger;
 
    VuoCompilerTriggerPort *manuallyFirableTrigger;
 
    set<VuoCompilerNode *> nodes;
 
    VuoCompilerNode *publishedInputNode;
 
    VuoCompilerNode *publishedOutputNode;
 
    bool ownsPublishedNodeClasses;
 
    set<VuoCable *> publishedCables;
 
    map<VuoCompilerTriggerPort *, map<Vertex, size_t> > vertexDistanceFromTrigger;
 
    map<VuoCompilerTriggerPort *, map<Vertex, bool> > triggerMustTransmitToVertex;
 
    map<VuoCompilerNode *, vector<VuoCompilerNode *> > downstreamNodesViaDataOnlyTransmission;
 
    map<VuoCompilerTriggerPort *, vector<VuoCompilerChain *> > chains;
 
    map<VuoCompilerTriggerPort *, map<VuoCompilerNode *, map<VuoCompilerNode *, bool> > > vertexMayTransmit;
 
    map<VuoCompilerTriggerPort *, map<VuoCompilerNode *, size_t> > numVerticesWithToNode;
 
    map<VuoCompilerTriggerPort *, vector<VuoCompilerNode *> > downstreamNodesForTrigger;
 
    map<VuoCompilerTriggerPort *, map<VuoCompilerNode *, vector<VuoCompilerNode *> > > downstreamNodesForNode;
 
    map<Vertex, set<Vertex> > downstreamVerticesNonBlocking;
 
    map<Vertex, set<Vertex> > downstreamVerticesNonBlockingOrDoor;
 
    map<VuoCompilerTriggerPort *, set<string> > publishedOutputNames;
 
    void initializeInstance(VuoCompilerComposition *composition, set<VuoCompilerCable *> potentialCables, VuoCompilerNode *publishedInputNode, VuoCompilerNode *publishedOutputNode, VuoCompilerNode *publishedInputTriggerNode, bool ownsPublishedNodeClasses, VuoCompilerNode *manuallyFirableTriggerNode);
    void makeTriggers(set<VuoNode *> nodes);
    void makeVerticesAndEdges(const set<VuoCable *> &cables);
    void makeDownstreamVerticesWithInclusionRule(VuoCompilerTriggerPort *trigger, std::function<bool(Edge)> includeEdge, map<Vertex, set<Vertex> > &_downstreamVertices, set<Vertex> &_repeatedVertices);
    void makeDownstreamVertices(void);
    void sortVertices(void);
    void makeVertexDistances(void);
    static bool compareTriggers(const pair<VuoCompilerTriggerPort *, size_t> &lhs, const pair<VuoCompilerTriggerPort *, size_t> &rhs);
    void makeDownstreamNodesViaDataOnlyTransmission(set<VuoNode *> nodes, set<VuoCable *> cables);
    static bool mustTransmit(const set<VuoCompilerCable *> &fromCables, const set<VuoCompilerCable *> &toCables);
    static bool mayTransmit(const set<VuoCompilerCable *> &fromCables, const set<VuoCompilerCable *> &toCables);
    bool mustTransmit(Vertex vertex, VuoCompilerTriggerPort *trigger);
    bool mayTransmit(Vertex vertex, VuoCompilerTriggerPort *trigger);
    bool mayTransmit(VuoCompilerNode *node, VuoCompilerTriggerPort *trigger);
    bool mayTransmit(VuoCompilerNode *fromNode, VuoCompilerNode *toNode);
    VuoPort * getOutputPortOnPublishedInputNode(size_t publishedInputPortIndex);
    VuoPort * getGatherPortOnPublishedOutputNode(void);
    size_t getNumVerticesWithFromNode(VuoCompilerNode *fromNode, VuoCompilerTriggerPort *trigger);
    size_t getNumVerticesWithToNode(VuoCompilerNode *toNode, VuoCompilerTriggerPort *trigger);
    bool areNodesPartiallyOverlappedByAnotherTrigger(const vector<VuoCompilerNode *> &nodes, VuoCompilerTriggerPort *trigger);
 
    friend class TestVuoCompilerBitcodeGenerator;
};