C:/Users/duhem/Desktop/FoRTReSS/FoRTReSS/FoRTReSS/src/RZ.h

Go to the documentation of this file.

#ifndef RZ_H
#define RZ_H

#include <iostream>
#include <string>
#include <vector>
#include <map>
using namespace std;

#include "device.h"
#include "coordinates.h"
#include "interface_location.h"
#include "utils.h"

enum ResourceConstraint{UNUSED, USED, STATIC, NOT_RECONFIGURABLE};

enum RZExtensionReturnValue {SUCCESS, END_OF_LINE, RESTRICTED_COLUMN};

class RZ {

private:

        static double VERTEX_COST;
        static double TASK_CORRELATION_COST;
        static double INTERNAL_FRAGMENTATION_COST;
        static int MINIMUM_DISTANCE_BETWEEN_RZ;

        // RZ characterization
        static int static_rz_id;
        int x0, y0, height;
        //int id;
        string id;
        double cost;
        Device *device;
        bool reverse;

        // Resources
        vector<vector<pair<RBType, ResourceConstraint> > > resourcesArray;
        map<RBType, int> constrainedResourcesCount;

        // Compatible tasks
        vector<string> compatibleTasks;
        int nbIncompatibleTasks;

        double resourceWastage;


public:
        RZ(int _x0, int _y0, int _height, Device *dev, bool rev) : x0(_x0), y0(_y0), height(_height), device(dev), reverse(rev) {
                id = Utils::itoa(static_rz_id);
                static_rz_id++;
                nbIncompatibleTasks = 0;
                resourceWastage = 0;
        }

        RZ(string rz_id, int _x0, int _y0, int _height, Device *dev, bool rev) : x0(_x0), y0(_y0), height(_height), device(dev), reverse(rev) {
                id = rz_id;
                static_rz_id++;
                nbIncompatibleTasks = 0;
                resourceWastage = 0;
        }

        RZ(const RZ &rz) {
                x0 = rz.x0;
                y0 = rz.y0;
                id = Utils::itoa(static_rz_id);
                //id = rz.id;
                static_rz_id++;
                height = rz.height;
                device = rz.device;
                resourcesArray = rz.resourcesArray;
                constrainedResourcesCount = rz.constrainedResourcesCount;
                cost = rz.cost;
                resourcesArray = rz.resourcesArray;
                reverse = rz.reverse;
                nbIncompatibleTasks = rz.nbIncompatibleTasks;
                resourceWastage = rz.resourceWastage;
        }

        // Getters
        int getX0(void);
        int getY0(void);
        int getHeight(void);
        map<RBType, int> getConstrainedResourcesCount(void);
        vector<vector<pair<RBType, ResourceConstraint> > > * getResourcesArrayPtr(void);
        int getRZCost(void) const;
        bool isReversed(void);
        string getID(void) const;
        Device * getDevicePtr(void);
        
        // RZ modification
        RZExtensionReturnValue extendRZ(void);
        void updateConstrainedResources();

        // Misc
        void printRZ(void);
        void info(void) const;
        int computeBitstreamSize(void);
        bool constrainsColumn(Coordinates c);

        // Cost
        void computeCost(void);

        // UCF generation
        void generateUCF(string taskname);
        void generateUCF(string taskname, string pblock_name, ofstream& file);

        // XML generation
        /*void generateXML(string taskname);
        void generateXML(string taskname, string pblock_name, ofstream& file);*/

        // Operators overloadings
        bool operator==(const RZ &rz) const;
        bool operator!=(const RZ &rz) const;

        // Distance / overlapping
        int horizontalDistance(const RZ &other);
        int verticalDistance(const RZ &other);
        bool isOverlappingRZ(const RZ &other);
        bool overlapsRZInSet(vector<RZ> &rzs);

        // Compatible tasks
        void addCompatibleTask(string task);
        void setNbIncompatibleTasks(int nbTasks);
        int getNbIncompatibleTasks(void);
        vector<string> getCompatibleTaskVector(void);
        void clearCompatibleTasks(void);

        // Setters for static variables from FoRTReSS
        static void setTaskCorrelationCost(double c);
        static void setRZShapeCost(double c);
        static void setInternalFragmentationCost(double c);
        static void setMinimumDistanceBetweenRZs(int val);

        void setResourceWastage(double val);

        bool isResourcePositionOK(InterfaceLocation loc);

        void setResourcesArray(vector<vector<pair<RBType, ResourceConstraint> > > &vec);

        // XML helper functions
        bool areColumnsIdentical(int col1, int col2);
        bool isColumnIdenticallyConstrained(int col);

        void setID(string);

};

#endif