DeviceInfo.h

Go to the documentation of this file.

 
#ifndef _DeviceINFO
#define _DeviceINFO
 
#include "strPrint.h"
#include <assert.h>
#include <fstream>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
 
class DeviceInfo
{
  public:
    enum DeviceElementType
    {
        DeviceElementType_BEL = 0,
        DeviceElementType_Site,
        DeviceElementType_Tile,
        DeviceElementType_CLOCKREGION,
        DeviceElementType_Device
    };
 
    class DeviceElement
    {
      public:
        DeviceElement(std::string &name, DeviceElement *parentPtr, DeviceElementType type, int id)
            : name(name), parentPtr(parentPtr), type(type), id(id)
        {
        }
 
        DeviceElement(std::string &name, DeviceElementType type, int id)
            : name(name), parentPtr(nullptr), type(type), id(id)
        {
        }
 
        virtual ~DeviceElement()
        {
        }
 
        inline std::string &getName()
        {
            return name;
        }
        inline DeviceElement *getParentPtr()
        {
            return parentPtr;
        }
        inline DeviceElementType getElementType()
        {
            return type;
        }
        inline int getElementIdInParent()
        {
            return id;
        }
 
      private:
        std::string name;
        DeviceElement *parentPtr;
        DeviceElementType type;
        int id;
    };
 
    class DeviceBEL;
    class DeviceSite;
    class DeviceTile;
    class ClockRegion;
    class ClockColumn;
 
    class DeviceBEL : public DeviceElement
    {
      public:
        DeviceBEL(std::string &name, std::string &BELType, DeviceElement *parentPtr, int id)
            : DeviceElement(name, parentPtr, DeviceElementType_BEL, id), BELType(BELType)
        {
            setSite(parentPtr);
        }
 
        ~DeviceBEL()
        {
        }
 
        void setSite(DeviceElement *parentPtr);
        inline DeviceSite *getSite()
        {
            return site;
        };
        inline std::string &getBELType()
        {
            return BELType;
        }
 
      private:
        std::string BELType;
        DeviceSite *site = nullptr;
        // TODO: also record the pins on BEL for later routing.
    };
 
    class DeviceSite : public DeviceElement
    {
      public:
        DeviceSite(std::string &name, std::string &siteType, DeviceElement *parentPtr, float locX, float locY,
                   int clockRegionX, int clockRegionY, int id)
            : DeviceElement(name, parentPtr, DeviceElementType_Site, id), siteType(siteType), locX(locX), locY(locY),
              clockRegionX(clockRegionX), clockRegionY(clockRegionY)
        {
            setTile(parentPtr);
 
            // extract the integer XY from the siteName from later processing
            // WARNING: In the site name, these XY values are not actual LOCATION!!!
            if (name.find('_') != std::string::npos)
            {
                std::string tmpName = name.substr(name.rfind('_') + 1, name.size() - name.rfind('_') - 1);
                if (tmpName.find('Y') != std::string::npos)
                {
                    siteY = std::stoi(tmpName.substr(tmpName.find('Y') + 1, tmpName.size() - tmpName.find('Y') - 1));
                    siteX = std::stoi(tmpName.substr(tmpName.find('X') + 1, tmpName.find('Y') - tmpName.find('X') - 1));
                }
                else
                {
                    siteX = -1;
                    siteY = -1;
                }
            }
            else
            {
                siteX = -1;
                siteY = -1;
            }
        }
 
        ~DeviceSite()
        {
            if (sitePins)
                delete sitePins;
        }
 
        class DeviceSitePinInfos
        {
          public:
            DeviceSitePinInfos()
            {
                refPinsName.clear();
                name2offsetY.clear();
                name2offsetX.clear();
            }
            ~DeviceSitePinInfos()
            {
            }
            std::vector<std::string> refPinsName;
            std::map<std::string, float> name2offsetX;
            std::map<std::string, float> name2offsetY;
        };
 
        void setTile(DeviceElement *parentTilePtr);
        inline DeviceTile *getTile()
        {
            assert(parentTile);
            return parentTile;
        };
 
        void setParentSite(DeviceElement *parentSitePtr);
        inline DeviceSite *getParentSite()
        {
            return parentSite;
        };
 
        void addChildSite(DeviceElement *parentSitePtr);
        inline std::vector<DeviceSite *> &getChildrenSites()
        {
            return childrenSites;
        };
 
        inline void setSiteLocation(float x, float y)
        {
            locX = x;
            locY = y;
        };
 
        inline std::string &getSiteType()
        {
            return siteType;
        };
 
        inline void addChildBEL(DeviceBEL *child)
        {
            childrenBELs.push_back(child);
        };
 
        inline std::vector<DeviceBEL *> &getChildrenBELs()
        {
            return childrenBELs;
        };
 
        inline float X()
        {
            return locX;
        }
        inline float Y()
        {
            return locY;
        }
 
        inline DeviceSitePinInfos *getSitePinInfos()
        {
            return sitePins;
        }
        inline void setSitePinInfos(DeviceSitePinInfos *_sitePins)
        {
            sitePins = _sitePins;
        }
 
        inline bool isOccupied()
        {
            return occupied;
        }
        inline void setOccupied()
        {
            occupied = true;
        }
 
        inline bool isMapped()
        {
            return mapped;
        }
        inline void setMapped()
        {
            mapped = true;
        }
        inline void resetMapped()
        {
            mapped = false;
        }
 
        inline int getSiteY()
        {
            assert(siteY >= 0);
            return siteY;
        }
 
        inline int getSiteX()
        {
            assert(siteX >= 0);
            return siteX;
        }
 
        inline int getClockRegionX()
        {
            return clockRegionX;
        }
 
        inline int getClockRegionY()
        {
            return clockRegionY;
        }
 
        inline void setClockRegion(ClockRegion *_clockRegion)
        {
            clockRegion = _clockRegion;
        }
 
        inline ClockRegion *getClockRegion()
        {
            return clockRegion;
        }
 
        inline void setClockHalfColumn(ClockColumn *_clockHalfColumn)
        {
            clockHalfColumn = _clockHalfColumn;
        }
 
        inline ClockColumn *getClockHalfColumn()
        {
            return clockHalfColumn;
        }
 
      private:
        std::string siteType;
        ClockRegion *clockRegion = nullptr;
        ClockColumn *clockHalfColumn = nullptr;
        std::vector<DeviceBEL *> childrenBELs;
        DeviceSite *parentSite; // mainly to handle overlapped sites
        std::vector<DeviceSite *> childrenSites;
        DeviceTile *parentTile = nullptr;
        DeviceSitePinInfos *sitePins = nullptr;
        float locX;
        float locY;
        int clockRegionX = -1;
        int clockRegionY = -1;
        int siteY;
        int siteX;
 
        bool occupied = false;
 
        bool mapped = false;
    };
 
    class DeviceTile : public DeviceElement
    {
      public:
        DeviceTile(std::string &name, std::string &tileType, DeviceInfo *device, int id)
            : DeviceElement(name, DeviceElementType_Tile, id), tileType(tileType), device(device)
        {
            if (name.rfind("X") != std::string::npos && name.rfind("Y") != std::string::npos)
            {
                tileIdX = std::stoi(name.substr(name.rfind("X") + 1, name.rfind("Y") - name.rfind("X") - 1));
                tileIdY = std::stoi(name.substr(name.rfind("Y") + 1, name.size() - name.rfind("Y") - 1));
            }
        }
 
        ~DeviceTile()
        {
        }
 
        void addChildSite(DeviceElement *sitePtr);
        inline std::vector<DeviceSite *> &getChildrenSites()
        {
            return childrenSites;
        };
        inline std::string &getTileType()
        {
            return tileType;
        }
 
        inline int getTileIdX()
        {
            return tileIdX;
        }
 
        inline int getTileIdY()
        {
            return tileIdY;
        }
 
      private:
        std::string tileType;
        std::vector<DeviceSite *> childrenSites;
        DeviceInfo *device;
        int tileIdX = -1,
            tileIdY = -1; // idX/idY are not the exact locations. It can be used to detect the half clock column.
    };
 
    class ClockColumn
    {
      public:
        ClockColumn()
        {
            sites.clear();
            clockNetId2Cnt.clear();
            clockNetId2CellIds.clear();
            clockNetId2Sites.clear();
        };
        ~ClockColumn()
        {
            sites.clear();
            clockNetId2Cnt.clear();
            clockNetId2CellIds.clear();
            clockNetId2Sites.clear();
        }
 
        void addSite(DeviceSite *curSite)
        {
            if (curSite->X() < left)
                left = curSite->X();
            if (curSite->X() > right)
                right = curSite->X();
            if (curSite->getName().find("SLICE") != std::string::npos)
            {
                if (curSite->Y() > top)
                    top = curSite->Y();
                if (curSite->Y() < bottom)
                    bottom = curSite->Y();
            }
            sites.push_back(curSite);
        }
 
        inline std::vector<DeviceSite *> &getSites()
        {
            return sites;
        }
 
        void resetClockInfo()
        {
            clockNetId2Cnt.clear();
            clockNetId2CellIds.clear();
            clockNetId2Sites.clear();
        }
 
        inline void addClockNetId(int clockNetId, int cellId)
        {
            if (clockNetId2Cnt.find(clockNetId) == clockNetId2Cnt.end())
            {
                clockNetId2Cnt[clockNetId] = 0;
            }
            clockNetId2Cnt[clockNetId] += 1;
            if (clockNetId2CellIds.find(clockNetId) == clockNetId2CellIds.end())
            {
                clockNetId2CellIds[clockNetId] = std::vector<int>();
            }
            clockNetId2CellIds[clockNetId].push_back(cellId);
        }
 
        inline int getClockNum()
        {
            return clockNetId2Cnt.size();
        }
 
        inline void setBoundary(float _left, float _right, float _top, float _bottom)
        {
            left = _left;
            right = _right;
            top = _top;
            bottom = _bottom;
        }
 
        inline void setLeft(float x)
        {
            left = x;
        }
 
        inline void setRight(float x)
        {
            right = x;
        }
 
        inline void setTop(float y)
        {
            top = y;
        }
 
        inline void setBottom(float y)
        {
            bottom = y;
        }
 
        inline std::map<int, std::vector<int>> &getClockNetId2CellIds()
        {
            return clockNetId2CellIds;
        }
 
        inline unsigned int getClockNumLimit()
        {
            return clockLimit;
        }
 
        inline void setId(unsigned int _id)
        {
            id = _id;
        }
 
        inline unsigned int getId()
        {
            return id;
        }
 
        inline float getLeft()
        {
            return left;
        }
 
        inline float getRight()
        {
            return right;
        }
 
        inline float getTop()
        {
            return top;
        }
 
        inline float getBottom()
        {
            return bottom;
        }
 
      private:
        int id;
        std::vector<DeviceSite *> sites;
        float left = 1000000, right = -1000000, top = -1000000, bottom = 1000000;
 
        std::map<int, int> clockNetId2Cnt;
 
        std::map<int, std::vector<int>> clockNetId2CellIds;
        std::map<int, DeviceSite *> clockNetId2Sites;
        unsigned int clockLimit = 12;
    };
 
    class ClockRegion
    {
      public:
        ClockRegion(DeviceSite *curSite)
        {
            assert(curSite);
            sites.clear();
            clockColumns.clear();
            sites.push_back(curSite);
            gridX = curSite->getClockRegionX();
            gridY = curSite->getClockRegionY();
            curSite->setClockRegion(this);
            leftX = curSite->X();
            rightX = curSite->X();
            topY = curSite->Y();
            bottomY = curSite->Y();
            tiles.insert(curSite->getTile());
        }
 
        ~ClockRegion()
        {
            sites.clear();
            for (auto &row : clockColumns)
            {
                for (auto clockColumn : row)
                {
                    if (clockColumn)
                        delete clockColumn;
                }
            }
            clockColumns.clear();
        }
 
        inline void addSite(DeviceSite *tmpSite)
        {
            assert(tmpSite);
            tmpSite->setClockRegion(this);
            if (tmpSite->X() < leftX)
                leftX = tmpSite->X();
            if (tmpSite->X() > rightX)
                rightX = tmpSite->X();
            if (tmpSite->getName().find("SLICE") != std::string::npos)
            {
                if (tmpSite->Y() > topY)
                    topY = tmpSite->Y();
                if (tmpSite->Y() < bottomY)
                    bottomY = tmpSite->Y();
            }
            sites.push_back(tmpSite);
            tiles.insert(tmpSite->getTile());
        }
 
        inline void setLeft(float x)
        {
            leftX = x;
        }
 
        inline void setRight(float x)
        {
            rightX = x;
        }
 
        inline void setTop(float y)
        {
            topY = y;
        }
 
        inline void setBottom(float y)
        {
            bottomY = y;
        }
 
        inline float getLeft()
        {
            return leftX;
        }
 
        inline float getRight()
        {
            return rightX;
        }
 
        inline float getTop()
        {
            return topY;
        }
 
        inline float getBottom()
        {
            return bottomY;
        }
 
        void mapSiteToClockColumns();
 
        void resetClockUtilizationInfo()
        {
            for (auto &row : clockColumns)
            {
                for (auto clockColumn : row)
                {
                    clockColumn->resetClockInfo();
                }
            }
        }
 
        inline void addClockAndCell(int clockNetId, int cellId, float x, float y)
        {
            float offsetXInRegion = x - leftX;
            float offsetYInRegion = y - bottomY;
 
            // this approach is not accurate enought since the slice columns are not evenly
            // distributed in a clock region. However, it is fast for frequently checking of
            // clock utilization
            int colX = offsetXInRegion / colWidth;
            int colY = offsetYInRegion / colHeight;
            assert(colX >= -1);
            assert(colY >= -1);
            assert(clockColumns.size());
            assert(colY <= (int)clockColumns.size());
            assert(colX <= (int)clockColumns[0].size());
            if (colX < 0)
                colX = 0;
            if (colY < 0)
                colY = 0;
            if (colX >= (int)clockColumns[0].size())
            {
                colX = clockColumns[0].size() - 1;
            }
            if (colY >= (int)clockColumns.size())
            {
                colY = clockColumns.size() - 1;
            }
            clockColumns[colY][colX]->addClockNetId(clockNetId, cellId);
        }
 
        inline int getMaxUtilizationOfClockColumns()
        {
            int res = 0;
            for (auto &row : clockColumns)
            {
                for (auto clockColumn : row)
                {
                    if (clockColumn)
                    {
                        if (clockColumn->getClockNum() > res)
                        {
                            res = clockColumn->getClockNum();
                        }
                    }
                }
            }
            return res;
        }
 
        inline ClockColumn *getMaxUtilizationClockColumnsPtr()
        {
            int res = 0;
            ClockColumn *resPtr = nullptr;
            for (auto &row : clockColumns)
            {
                for (auto clockColumn : row)
                {
                    if (clockColumn)
                    {
                        if (clockColumn->getClockNum() > res)
                        {
                            res = clockColumn->getClockNum();
                            resPtr = clockColumn;
                        }
                    }
                }
            }
            return resPtr;
        }
 
        inline std::vector<std::vector<ClockColumn *>> &getClockColumns()
        {
            return clockColumns;
        }
 
      private:
        std::vector<DeviceSite *> sites;
        std::set<DeviceTile *> tiles;
        std::vector<std::vector<ClockColumn *>> clockColumns;
        int columnNumY = 2;
        int gridX, gridY;
        float leftX, rightX, topY, bottomY;
        int leftSiteX, bottomSiteY, rightSiteX, topSiteY;
        int leftTileIdX = 1000000, bottomTileIdY = 1000000, rightTileIdX = -1, topTileIdY = -1;
        float colHeight;
        float colWidth;
    };
 
    // clang-format off
    // clang-format on
    DeviceInfo(std::map<std::string, std::string> &JSONCfg, std::string _deviceName);
    ~DeviceInfo()
    {
        for (auto bel : BELs)
            delete bel;
        for (auto site : sites)
            delete site;
        for (auto tile : tiles)
            delete tile;
    }
 
    void printStat(bool verbose = false);
 
    inline void addBELTypes(std::string &strBELType)
    {
        BELTypes.insert(strBELType);
    }
 
    void addBEL(std::string &BELName, std::string &BELType, DeviceSite *parentSite);
 
    inline void addSiteTypes(std::string &strSiteType)
    {
        siteTypes.insert(strSiteType);
    }
 
    void addSite(std::string &siteName, std::string &siteType, float locx, float locy, int clockRegionX,
                 int clockRegionY, DeviceTile *parentTile);
 
    inline void addTileTypes(std::string &strTileType)
    {
        tileTypes.insert(strTileType);
    }
    void addTile(std::string &tileName, std::string &tileType);
 
    inline std::string &getDeviceName()
    {
        return deviceName;
    }
 
    inline std::set<std::string> &getBELTypes()
    {
        return BELTypes;
    }
 
    inline DeviceBEL *getBELWithName(std::string &BELName)
    {
        assert(name2BEL.find(BELName) != name2BEL.end());
        return name2BEL[BELName];
    }
 
    inline std::vector<DeviceBEL *> &getBELsInType(std::string &BELType)
    {
        assert(BELType2BELs.find(BELType) != BELType2BELs.end());
        return BELType2BELs[BELType];
    }
 
    inline std::set<std::string> &getSiteTypes()
    {
        return siteTypes;
    }
 
    inline DeviceSite *getSiteWithName(std::string &siteName)
    {
        assert(name2Site.find(siteName) != name2Site.end());
        return name2Site[siteName];
    }
 
    inline std::vector<DeviceSite *> &getSitesInType(std::string &siteType)
    {
        assert(siteType2Sites.find(siteType) != siteType2Sites.end());
        return siteType2Sites[siteType];
    }
 
    inline std::set<std::string> &getTileTypes()
    {
        return tileTypes;
    }
 
    inline DeviceTile *getTileWithName(std::string &tileName)
    {
        assert(name2Tile.find(tileName) != name2Tile.end());
        return name2Tile[tileName];
    }
 
    inline std::vector<DeviceTile *> &getTilesInType(std::string &tileType)
    {
        assert(tileType2Tiles.find(tileType) != tileType2Tiles.end());
        return tileType2Tiles[tileType];
    }
 
    void loadPCIEPinOffset(std::string specialPinOffsetFileName);
 
    inline std::vector<DeviceBEL *> &getBELs()
    {
        return BELs;
    }
    inline std::vector<DeviceSite *> &getSites()
    {
        return sites;
    }
    inline std::vector<DeviceTile *> &getTiles()
    {
        return tiles;
    }
 
    inline DeviceBEL *getBEL(std::string &Name)
    {
        assert(name2BEL.find(Name) != name2BEL.end());
        return name2BEL[Name];
    }
    inline DeviceSite *getSite(std::string &Name)
    {
        assert(name2Site.find(Name) != name2Site.end());
        return name2Site[Name];
    }
    inline DeviceTile *getTile(std::string &Name)
    {
        assert(name2Tile.find(Name) != name2Tile.end());
        return name2Tile[Name];
    }
 
    inline std::string getBELType2FalseBELType(std::string curBELType)
    {
        if (BELType2FalseBELType.find(curBELType) == BELType2FalseBELType.end())
        {
            return curBELType;
        }
        else
        {
            return BELType2FalseBELType[curBELType];
        }
    }
 
    void loadBELType2FalseBELType(std::string curFileName);
 
    void resetAllSiteMapping()
    {
        for (auto curSite : sites)
        {
            if (!curSite->isOccupied())
            {
                curSite->resetMapped();
            }
        }
    }
 
    void mapClockRegionToArray();
 
    inline float getBoundaryTolerance()
    {
        return boundaryTolerance;
    }
 
    inline void getClockRegionByLocation(float locX, float locY, int &clockRegionX, int &clockRegionY)
    {
        int resX = 0, resY = 0;
        for (int j = 0; j < clockRegionNumX; j++)
        {
            if (clockRegionXBounds[j] < locX)
            {
                resX = j;
            }
            else
            {
                break;
            }
        }
        for (int i = 0; i < clockRegionNumY; i++)
        {
            if (clockRegionYBounds[i] < locY)
            {
                resY = i;
            }
            else
            {
                break;
            }
        }
        clockRegionX = resX;
        clockRegionY = resY;
    }
 
    inline int getClockRegionNumX()
    {
        return clockRegionNumX;
    }
 
    inline int getClockRegionNumY()
    {
        return clockRegionNumY;
    }
 
    void recordClockRelatedCell(float locX, float locY, int regionX, int regionY, int cellId, int netId);
 
    inline int getMaxUtilizationOfClockColumns_InClockRegion(int regionX, int regionY)
    {
        return clockRegions[regionY][regionX]->getMaxUtilizationOfClockColumns();
    }
 
    inline std::vector<std::vector<ClockRegion *>> &getClockRegions()
    {
        return clockRegions;
    }
 
    inline std::vector<ClockColumn *> &getClockColumns()
    {
        return clockColumns;
    }
 
  private:
    std::string deviceName;
    std::set<std::string> BELTypes;
    std::map<std::string, std::vector<DeviceBEL *>> BELType2BELs;
    std::vector<DeviceBEL *> BELs;
 
    std::set<std::string> siteTypes;
    std::map<std::string, std::vector<DeviceSite *>> siteType2Sites;
    std::vector<DeviceSite *> sites;
 
    std::set<std::string> tileTypes;
    std::map<std::string, std::vector<DeviceTile *>> tileType2Tiles;
    std::vector<DeviceTile *> tiles;
 
    std::map<std::string, std::string> BELType2FalseBELType;
 
    std::map<std::string, DeviceBEL *> name2BEL;
    std::map<std::string, DeviceSite *> name2Site;
    std::map<std::string, DeviceTile *> name2Tile;
 
    std::map<std::pair<int, int>, ClockRegion *> coord2ClockRegion;
    std::vector<std::vector<ClockRegion *>> clockRegions;
    std::vector<ClockColumn *> clockColumns;
    std::vector<float> clockRegionXBounds;
    std::vector<float> clockRegionYBounds;
 
    std::map<std::string, std::string> &JSONCfg;
    std::string deviceArchievedTextFileName;
    std::string specialPinOffsetFileName;
 
    float boundaryTolerance = 0.5;
    int clockRegionNumX = 1;
    int clockRegionNumY = 1;
};
 
#endif