Dataflow.h

#ifndef DATAFLOW_H
#define DATAFLOW_H

#include <list>
#include <set>
#include <string>
#include <vector>

namespace Dataflow
{

// Identifiers for the main objects of a dataflow system.
// Functions, blocks, channels, ports and basic blocks are represented by a unique identifier.
// (integers starting from 0). Each type has a different space of identifiers.
// Eventually, the range of id's can be sparse, i.e., when functions, blocks,
// channels and ports are removed, the original id's do not change.

const int invalidDataflowID = -1;

using funcID = int;
using blockID = int;
using channelID = int;
using portID = int;

// Collections of dataflow objects

using vecFuncs = std::vector<funcID>;
using setFuncs = std::set<funcID>;
using listFuncs = std::list<funcID>;
using vecBlocks = std::vector<blockID>;
using setBlocks = std::set<blockID>;
using listBlocks = std::list<blockID>;
using vecPorts = std::vector<portID>;
using setPorts = std::set<portID>;
using listPorts = std::list<portID>;
using vecChannels = std::vector<channelID>;
using setChannels = std::set<channelID>;
using listChannels = std::list<channelID>;

enum BlockType {OPERATOR,
                ELASTIC_BUFFER,
                FORK,
                BRANCH,
                MERGE,
                DEMUX,
                SELECT,
                CONSTANT,
                FUNC_ENTRY,
                FUNC_EXIT,
                SOURCE,
                SINK,
                MUX,
                CNTRL_MG,
                LSQ, 
                MC,
                DISTRIBUTOR,
                SELECTOR,
                UNKNOWN
               };

enum PortType {GENERIC_PORT,    // Most ports will be generic
               SELECTION_PORT,  // Selection port for branch/select/demux blocks
               TRUE_PORT,       // True port for branch and select blocks
               FALSE_PORT       // False port for branch and select blocks
              };

enum PortDirection {INPUT_PORTS,
                    OUTPUT_PORTS,
                    ALL_PORTS
                   };

class DFnetlist_Impl;
class DFlib_Impl;

class DFnetlist
{

public:
      DFnetlist_Impl* DFI;    

    DFnetlist();

    ~DFnetlist();

    DFnetlist(const std::string& name);

    DFnetlist(FILE* file);

    DFnetlist(const std::string& name, const std::string& name_bb);

    DFnetlist(const DFnetlist& other);

    void setMilpSolver(const std::string& solver = "cbc");

    bool check();

    const std::string& getName() const;

    blockID createBlock(BlockType type, const std::string& name = "");

    blockID getBlock(const std::string& name) const;

    const std::string& getBlockName(blockID id) const;

    double getBlockDelay(blockID id, int indx) const;

    void setBlockDelay(blockID id, double d, int indx);

    double getBlockRetimingDiff(blockID id) const;

    void setBlockRetimingDiff(blockID id, double retimingDiff);


    int getLatency(blockID id) const;

    void setLatency(blockID id, int lat);

    int getInitiationInterval(blockID id) const;

    void setInitiationInterval(blockID id, int ii);

    void setExecutionFrequency(blockID id, double freq);

    int getExecutionFrequency(blockID id) const;

    void setTrueFrac(blockID id, double freq);

    double getTrueFrac(blockID id) const;

    int getBufferSize(blockID id) const;

    void setBufferSize(blockID id, int slots);

    bool isBufferTransparent(blockID id) const;

    void setBufferTransparency(blockID id, bool value);

    blockID getBlockFromPort(portID p) const;

    void removeBlock(blockID block);

    portID createPort(blockID block, bool isInput, const std::string& name="", int width = -1, PortType type = GENERIC_PORT);

    void removePort(portID port);

    portID getPort(blockID block, const std::string& name) const;

    const std::string& getPortName(portID port, bool full=true) const;

    PortType getPortType(portID port) const;

    bool isInputPort(portID port) const;

    bool isOutputPort(portID port) const;

    int getPortWidth(portID port) const;

    bool isBooleanPort(portID port) const;

    bool isControlPort(portID port) const;

    double getPortDelay(portID port) const;

    void setPortDelay(portID port, double d);

    const setPorts& getPorts(blockID id, PortDirection dir) const;

    portID getConditionalPort(blockID id) const;

    portID getTruePort(blockID id) const;

    portID getFalsePort(blockID id) const;

    portID getDemuxDataPort(blockID id) const;

    portID getDemuxComplementaryPort(portID port) const;

    channelID getConnectedChannel(portID port) const;

    BlockType getBlockType(blockID block) const;

    bool isPortConnected(portID port) const;

    portID getConnectedPort(portID port) const;

    channelID createChannel(portID src, portID dst);

    portID getSrcPort(channelID id) const;

    portID getDstPort(channelID id) const;

    void removeChannel(channelID id);

    std::string getChannelName(channelID id, bool full=true) const;

    channelID getChannelID(portID id); //Carmine 09.03.22 new function

    int getChannelBufferSize(channelID id) const;

    void setChannelBufferSize(blockID id, int slots);

    bool isChannelTransparent(channelID id) const;

    void setChannelTransparency(channelID id, bool value);

    void setChannelEB(channelID id);

    bool getChannelEB(channelID id);

    void setChannelFrequency(channelID id, double value);

    double getChannelFrequency(channelID id);

    bool hasBuffer(channelID id) const;

    blockID insertBuffer(channelID c, int slots, bool transparent);

    blockID insertBuffer(channelID c, int slots, bool transparent, bool EB);

    void removeBuffer(blockID buf);

    void setError(const std::string& err);

    const std::string& getError() const;

    void clearError();

    bool hasError() const;

    int numBlocks() const;

    int numChannels() const;

    int numPorts() const;

    bool validPort(portID p) const;

    bool validBlock(blockID id) const;

    bool validChannel(channelID id) const;

    void reduceMerges(); //Carmine 09.03.22 new function

    bool writeDot(const std::string& filename = "");

    bool writeDot(std::ostream& s);

    bool writeDotMG(const std::string& filename = "");
    bool writeDotMG(std::ostream& s);

    bool writeDotBB(std::ostream& s);
    bool writeDotBB(const std::string& filename = "");

    bool writeBasicBlockDot(const std::string& filename = "");

    bool writeBasicBlockDot(std::ostream& s);

    bool addElasticBuffers(double Period = 0, double BufferDelay = 0, bool maxThroughput = false, double coverage = 0);

    bool addElasticBuffersBB(double Period = 0, double BufferDelay = 0, bool maxThroughput = false, double coverage = 0, int timeout = -1, bool first_MG = false);

    bool addElasticBuffersBB_sc(double Period = 0, double BufferDelay = 0, bool maxThroughput = false, double coverage = 0, int timeout = -1, bool first_MG = false, const std::string& model_mode = "default", const std::string& lib_path="");

    void instantiateElasticBuffers();

    void instantiateAdditionalElasticBuffers(const std::string& filename);

    void hideElasticBuffers();

    void cleanElasticBuffers();

    void eraseNonSCC();

    void computeSCC(bool onlyMarked);

    void printBlockSCCs();

    bool calculateBasicBlocks();

    bool optimize();

    bool removeControl();

    double extractMarkedGraphs(double coverage);
};

class DFlib
{

    DFlib_Impl* DFLI;    

public:
    DFlib();

    ~DFlib();

    DFlib(const std::string& name);


    bool add(const std::string& filename);

    bool writeDot(const std::string& filename = "");

    void setError(const std::string& err);

    const std::string& getError() const;

    void clearError();

    bool hasError() const;

    int numFuncs() const;

    funcID getFuncID(const std::string& fname) const;

    DFnetlist& operator[](const std::string& fname);

    const DFnetlist& operator[](const std::string& fname) const;

    DFnetlist& operator[](funcID id);

    const DFnetlist& operator[](funcID id) const;
};

}
#endif // DATAFLOW_H