PlacementInfo.h

Go to the documentation of this file.

 
#ifndef _PlacementINFO
#define _PlacementINFO
 
#include "DesignInfo.h"
#include "DeviceInfo.h"
#include "Eigen/Core"
#include "Eigen/SparseCore"
#include "PlacementTimingInfo.h"
#include "Rendering/paintDB.h"
#include "dumpZip.h"
#include <assert.h>
#include <fstream>
#include <iostream>
#include <map>
#include <mutex>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <thread>
#include <vector>
 
class PlacementInfo
{
  public:
    enum PlacementUnitType
    {
        PlacementUnitType_UnpackedCell = 0,
        PlacementUnitType_Macro
    };
 
    class PlacementSiteTypeInfo;
    class PlacementBinInfo;
    class CompatiblePlacementTable;
    class PlacementNet;
 
    class CompatiblePlacementTable
    {
      public:
        CompatiblePlacementTable(std::string cellType2fixedAmoFileName, std::string cellType2sharedCellTypeFileName,
                                 std::string sharedCellType2BELtypeFileName, DesignInfo *designInfo,
                                 DeviceInfo *deviceInfo);
        ~CompatiblePlacementTable()
        {
        }
 
        std::vector<std::string> realBELTypes;
 
        std::map<std::string, int> realBELTypeName2ID;
 
        std::vector<std::string> sharedCellBELTypes;
 
        std::map<DesignInfo::DesignCellType, int> cellType2sharedBELTypeOccupation;
 
        std::map<DesignInfo::DesignCellType, std::vector<std::string>> cellType2sharedBELTypes;
 
        std::map<DesignInfo::DesignCellType, std::vector<int>> cellType2sharedBELTypeIDs;
 
        std::map<std::string, std::string> sharedCellType2SiteType;
 
        std::map<std::string, std::vector<std::string>> sharedCellType2BELNames;
 
        inline std::vector<int> &getPotentialBELTypeIDs(DesignInfo::DesignCell *cell)
        {
            // be careful, this function will remap the BELType according to the user configuration
            // for example, SLICEM_CARRY8 will be mapped to SLICEL_CARRY8, so they will be treated equally during cell
            // spreading.
            assert(cell);
            assert((unsigned int)cell->getCellId() < cellId2SharedCellBELTypeID.size());
            return cellId2SharedCellBELTypeID[cell->getCellId()];
        }
 
        inline std::vector<int> &getPotentialBELTypeIDs(DesignInfo::DesignCellType cellType)
        {
            // be careful, this function will not remap the BELType.
            return cellType2sharedBELTypeIDs[cellType];
        }
 
        inline int getSharedBELTypeId(std::string tmpStr)
        {
            assert(sharedCellBELTypeName2ID.find(tmpStr) != sharedCellBELTypeName2ID.end());
            return sharedCellBELTypeName2ID[tmpStr];
        }
 
        inline float getOccupation(DesignInfo::DesignCellType cellType)
        {
            return cellType2sharedBELTypeOccupation[cellType];
        }
 
        inline float getActualOccupation(DesignInfo::DesignCell *cell)
        {
            return cellId2Occupation[cell->getCellId()] * cellId2InfationRatio[cell->getCellId()];
        }
 
        inline float getInflateRatio(DesignInfo::DesignCell *cell)
        {
            return cellId2InfationRatio[cell->getCellId()];
        }
 
        inline float getActualOccupationByCellId(int id)
        {
            return cellId2Occupation[id] * cellId2InfationRatio[id];
        }
 
        inline std::vector<float> &getcellId2Occupation()
        {
            return cellId2Occupation;
        }
 
        inline std::vector<float> &getcellId2InfationRatio()
        {
            return cellId2InfationRatio;
        }
 
        void setBELTypeForCells(DesignInfo *designInfo);
 
        void resetCellOccupationToDefault();
 
      private:
        std::map<std::string, int> sharedCellBELTypeName2ID;
        std::vector<std::vector<int>> cellId2SharedCellBELTypeID;
        std::vector<float> cellId2Occupation;
        std::vector<float> cellId2InfationRatio;
        std::vector<float> defaultCellId2Occupation;
        DesignInfo *designInfo;
        DeviceInfo *deviceInfo;
    };
 
    class PlacementSiteTypeInfo
    {
      public:
        typedef struct location
        {
            float locX;
            float locY;
        } location;
 
        PlacementSiteTypeInfo(std::string siteType, std::vector<DeviceInfo::DeviceSite *> &correspondingSites)
            : siteType(siteType), correspondingSites(correspondingSites)
        {
            assert(correspondingSites.size() > 0);
 
            BELNames.clear();
            for (DeviceInfo::DeviceBEL *curBEL : correspondingSites[0]->getChildrenBELs())
            {
                BELNames.insert(curBEL->getBELType());
            }
 
            potentialLocations.clear();
            for (DeviceInfo::DeviceSite *curSite : correspondingSites)
            {
                location tmploc;
                tmploc.locX = curSite->X();
                tmploc.locY = curSite->Y();
                potentialLocations.push_back(tmploc);
            }
        }
 
        ~PlacementSiteTypeInfo()
        {
            potentialLocations.clear();
            BELNames.clear();
        }
 
      private:
        std::string siteType;
        std::set<std::string> BELNames;
        std::vector<location> potentialLocations;
        const std::vector<DeviceInfo::DeviceSite *> &correspondingSites;
    };
 
    class PlacementBinInfo
    {
      public:
        PlacementBinInfo(std::string sharedCellType, float leftX, float rightX, float bottomY, float topY, int row,
                         int column, CompatiblePlacementTable *compatiblePlacementTable)
            : sharedCellType(sharedCellType), compatiblePlacementTable(compatiblePlacementTable), leftX(leftX),
              rightX(rightX), topY(topY), bottomY(bottomY), row(row), column(column)
 
        {
            correspondingSites.clear();
            cells.clear();
        }
 
        ~PlacementBinInfo()
        {
            correspondingSites.clear();
            cells.clear();
        }
 
        inline float getManhattanDistanceTo(float inX, float inY)
        {
            if (leftX < inX && inX <= rightX && bottomY < inY && inY <= topY)
            {
                return 0;
            }
            if (leftX < inX && inX <= rightX)
            {
                return std::min(std::fabs(inY - topY), std::fabs(inY - bottomY));
            }
            if (bottomY < inY && inY <= topY)
            {
                return std::min(std::fabs(inX - leftX), std::fabs(inX - rightX));
            }
            return std::min(std::fabs(inX - leftX), std::fabs(inX - rightX)) +
                   std::min(std::fabs(inY - topY), std::fabs(inY - bottomY));
        }
 
        void addSiteIntoBin(DeviceInfo::DeviceSite *curSite);
 
        inline bool inRange(float x, float y)
        {
            return (x < rightX && x >= (leftX - 1e-3) && y < topY && y >= (bottomY - 1e-3));
        }
 
        inline bool inRangeY(float y)
        {
            return (y < topY && y >= bottomY);
        }
 
        inline void addCell(DesignInfo::DesignCell *cell, int occupationAdded)
        {
            mtx.lock();
            assert(cells.find(cell) == cells.end());
            cells.insert(cell);
            assert(occupationAdded >= 0);
            utilization += occupationAdded;
            mtx.unlock();
        }
 
        inline void removeCell(DesignInfo::DesignCell *cell, int occupationAdded)
        {
            // if (cell)
            mtx.lock();
            assert(cells.find(cell) != cells.end());
            cells.erase(cell);
            utilization -= occupationAdded;
            assert(utilization >= 0);
            mtx.unlock();
        }
 
        inline bool contains(DesignInfo::DesignCell *cell)
        {
            // if (cell)
            return cells.find(cell) != cells.end();
        }
 
        inline void reset()
        {
            cells.clear();
            utilization = 0;
            binShrinkRatio = requiredBinShrinkRatio;
            overflowCnt = 0;
            noOverflowCnt = 0;
            switchDemandForNets = 0;
            switchSupplyForNets = 0;
        }
 
        inline void shrinkBinBy(float r)
        {
            binShrinkRatio *= (1 - r);
        }
 
        inline void inflateBinBy(float r)
        {
            binShrinkRatio *= (1 + r);
        }
 
        inline void resetBinShrinkRatio()
        {
            binShrinkRatio = requiredBinShrinkRatio;
        }
 
        inline float getRequiredBinShrinkRatio()
        {
            return requiredBinShrinkRatio;
        }
 
        inline void setRequiredBinShrinkRatio(float r)
        {
            requiredBinShrinkRatio = r;
        }
 
        inline std::set<DesignInfo::DesignCell *> &getCells()
        {
            return cells;
        }
 
        inline float getBinShrinkRatio()
        {
            return binShrinkRatio;
        }
 
        inline float getUtilizationRate()
        {
            if (capacity == 0)
                return utilization / 0.01;
            assert(capacity != 0);
            return (float)utilization / (capacity * binShrinkRatio);
        }
 
        inline float getRealUtilizationRate()
        {
            if (cells.size())
            {
                std::vector<DesignInfo::DesignCell *> cellVec;
                cellVec.clear();
                for (auto cell : cells)
                {
                    cellVec.push_back(cell);
                }
                if (cellVec[0]->isLUT())
                {
                    float tmputilization = 0;
                    for (auto cell : cells)
                    {
                        if (cell->isLUT6())
                            tmputilization += 2.0;
                        else
                            tmputilization += 1;
                    }
                    return (float)tmputilization / capacity;
                }
                else
                {
                    return getUtilizationRate();
                }
            }
            return 0;
        }
 
        inline float getUtilization()
        {
            return (float)utilization;
        }
 
        inline float getCapacity()
        {
            return (float)capacity * binShrinkRatio;
        }
 
        inline bool isOverflow(float overflowThreshold)
        {
            if (capacity == 0)
            {
                if (utilization == 0)
                    return false;
                else
                    return true;
            }
            assert(utilization >= 0);
            assert(capacity != 0);
            return ((float)utilization / (capacity)) > overflowThreshold + eps;
            // return ((float)utilization / (binShrinkRatio * capacity)) > overflowThreshold + eps;
        }
 
        inline bool canAddMore(int BELAmo)
        {
            if (capacity == 0)
                return false;
            return ((float)(utilization + BELAmo) / (binShrinkRatio * capacity)) <= 1.00 + eps;
        }
 
        inline int Y()
        {
            return row;
        }
 
        inline int X()
        {
            return column;
        }
 
        inline float left()
        {
            return leftX;
        }
 
        inline float right()
        {
            return rightX;
        }
 
        inline float top()
        {
            return topY;
        }
 
        inline float bottom()
        {
            return bottomY;
        }
 
        inline std::string getType()
        {
            return sharedCellType;
        }
 
        inline void countOverflow()
        {
            overflowCnt++;
        }
 
        inline void countNoOverflow()
        {
            if (noOverflowCnt < 100)
            {
                noOverflowCnt++;
            }
        }
        inline void resetNoOverflowCounter()
        {
            noOverflowCnt = 0;
        }
        inline void resetOverflowCounter()
        {
            overflowCnt = 0;
        }
        inline int getNoOverflowCounter()
        {
            return noOverflowCnt;
        }
        inline int getOverflowCounter()
        {
            return overflowCnt;
        }
 
        inline std::vector<DeviceInfo::DeviceSite *> &getCorrespondingSites()
        {
            return correspondingSites;
        }
 
        inline std::string &getSharedCellType()
        {
            return sharedCellType;
        }
 
        inline void increaseSWDemandBy(float additionalDemand)
        {
            switchDemandForNets += additionalDemand;
        }
 
        inline float getSwitchDemandForNets() const
        {
            return switchDemandForNets;
        }
 
        inline void setClockRegionX(int _x)
        {
            clockRegionX = _x;
        }
 
        inline int getClockRegionX()
        {
            return clockRegionX;
        }
 
      private:
        std::string sharedCellType;
        std::vector<DeviceInfo::DeviceSite *> correspondingSites;
        CompatiblePlacementTable *compatiblePlacementTable;
        std::set<DesignInfo::DesignCell *> cells;
 
        int capacity = 0;
        int utilization = 0;
        float binShrinkRatio = 1.0;
        float requiredBinShrinkRatio = 1.0;
 
        const float leftX;
        const float rightX;
        const float topY;
        const float bottomY;
 
        float eps = 1e-5;
        const int row;
        const int column;
 
        int overflowCnt = 0;
        int noOverflowCnt = 0;
 
        float switchDemandForNets = 0.0;
        float switchSupplyForNets = 0.0; // only consider the general sites (DSP/BRAM/SLICE)
        std::mutex mtx;
 
        int clockRegionX = -1;
    };
 
    class PlacementHybridBinInfo
    {
      public:
        PlacementHybridBinInfo(PlacementBinInfo *curBin)
            : leftX(curBin->left()), rightX(curBin->right()), topY(curBin->top()), bottomY(curBin->bottom()),
              row(curBin->Y()), column(curBin->X())
        {
            mergedBins.clear();
            correspondingSites.clear();
            cells.clear();
            mergedBins.push_back(curBin);
        }
 
        ~PlacementHybridBinInfo()
        {
            correspondingSites.clear();
            cells.clear();
        }
 
        inline bool inRange(float x, float y)
        {
            return (x <= rightX && x > leftX && y <= topY && y > bottomY);
        }
 
        inline bool inRangeY(float y)
        {
            return (y <= topY && y > bottomY);
        }
 
        inline void addCell(DesignInfo::DesignCell *cell, int occupationAdded)
        {
            // if (cell)
            cells.insert(cell);
            utilization += occupationAdded;
        }
 
        inline void removeCell(DesignInfo::DesignCell *cell, int occupationAdded)
        {
            // if (cell)
            assert(cells.find(cell) != cells.end());
            cells.erase(cell);
            utilization -= occupationAdded;
        }
 
        inline bool contains(DesignInfo::DesignCell *cell)
        {
            // if (cell)
            return cells.find(cell) != cells.end();
        }
 
        inline void reset()
        {
            cells.clear();
            utilization = 0;
        }
 
        inline std::set<DesignInfo::DesignCell *> &getCells()
        {
            return cells;
        }
 
        inline float getUtilizationRate()
        {
            if (capacity == 0)
                return utilization / 0.01;
            assert(capacity != 0);
            return (float)binShrinkRatio * utilization / capacity;
        }
 
        inline float getUtilization()
        {
            return (float)utilization;
        }
 
        inline float getCapacity()
        {
            return (float)capacity / binShrinkRatio;
        }
 
        inline bool isOverflow()
        {
            if (capacity == 0)
            {
                if (utilization == 0)
                    return false;
                else
                    return true;
            }
            assert(capacity != 0);
            return ((float)binShrinkRatio * utilization / capacity) > 1.00 + eps;
        }
 
        inline bool canAddMore(int BELAmo)
        {
            if (capacity == 0)
                return false;
            return ((float)binShrinkRatio * (utilization + BELAmo) / capacity) <= 1.00 + eps;
        }
        inline void setYX(int i, int j)
        {
            row = i;
            column = j;
        }
 
        inline int Y()
        {
            return row;
        }
        inline int X()
        {
            return column;
        }
 
        inline float left()
        {
            return leftX;
        }
        inline float right()
        {
            return rightX;
        }
        inline float top()
        {
            return topY;
        }
        inline float bottom()
        {
            return bottomY;
        }
 
      private:
        std::vector<DeviceInfo::DeviceSite *> correspondingSites;
        std::vector<PlacementBinInfo *> mergedBins;
        std::set<DesignInfo::DesignCell *> cells;
        int capacity = 0;
        int utilization = 0;
        float binShrinkRatio = 1.0;
        float leftX;
        float rightX;
        float topY;
        float bottomY;
        float eps = 1e-5;
        int row;
        int column;
    };
 
    class PlacementUnit
    {
      public:
        PlacementUnit(std::string name, int id, PlacementUnitType unitType) : name(name), id(id), unitType(unitType)
        {
        }
        virtual ~PlacementUnit()
        {
        }
        void getAnchorLocation(float &x, float &y)
        {
            x = anchorX;
            y = anchorY;
        }
 
        inline float X()
        {
            return anchorX;
        }
 
        inline float Y()
        {
            return anchorY;
        }
 
        inline float lastX()
        {
            return lastAnchorX;
        }
 
        inline float lastY()
        {
            return lastAnchorY;
        }
 
        inline void setAnchorLocation(float x, float y)
        {
            assert(!locked);
            if (anchorX < -100 && anchorY < -100)
            {
                lastAnchorX = x;
                lastAnchorY = y;
            }
            else
            {
                lastAnchorX = anchorX;
                lastAnchorY = anchorY;
            }
            anchorX = x;
            anchorY = y;
        }
 
        inline void setSpreadLocation(float x, float y, float forgetRatio)
        {
            assert(!locked);
 
            if (lastSpreadX > -100 && lastSpreadY > -100)
            {
                assert(forgetRatio <= 1);
                x = x * forgetRatio + lastSpreadX * (1 - forgetRatio);
                y = y * forgetRatio + lastSpreadY * (1 - forgetRatio);
                // lastSpreadX = x;
                // lastSpreadY = y;
            }
            lastAnchorX = x;
            lastAnchorY = y;
            anchorX = x;
            anchorY = y;
        }
 
        inline void setSpreadLocation_WithLimitDisplacement(float x, float y, float forgetRatio,
                                                            float limitDisplacement)
        {
            assert(!locked);
 
            if (lastSpreadX > -100 && lastSpreadY > -100)
            {
                assert(forgetRatio <= 1);
                float disX = std::fabs(x - lastSpreadX) * forgetRatio;
                float disY = std::fabs(x - lastSpreadX) * forgetRatio;
                float dis = std::sqrt(disX * disX + disY * disY);
                if (dis / limitDisplacement > 1)
                    forgetRatio /= (dis / limitDisplacement);
 
                x = x * forgetRatio + lastSpreadX * (1 - forgetRatio);
                y = y * forgetRatio + lastSpreadY * (1 - forgetRatio);
 
                // lastSpreadX = x;
                // lastSpreadY = y;
            }
            lastAnchorX = x;
            lastAnchorY = y;
            anchorX = x;
            anchorY = y;
        }
 
        inline void setAnchorLocationAndForgetTheOriginalOne(float x, float y)
        {
            assert(!locked);
 
            lastAnchorX = x;
            lastAnchorY = y;
            anchorX = x;
            anchorY = y;
        }
 
        inline void recordSpreadLocatin()
        {
            lastSpreadX = anchorX;
            lastSpreadY = anchorY;
        }
 
        inline void setFixed()
        {
            assert(!locked);
            fixed = true;
        }
 
        inline void setUnfixed()
        {
            assert(!locked);
            fixed = false;
        }
 
        inline void setLocked()
        {
            locked = true;
        }
 
        inline void setUnlocked()
        {
            locked = false;
        }
 
        inline bool isLocked()
        {
            return locked;
        }
 
        inline void setPlaced()
        {
            assert(!locked);
            placed = true;
        }
 
        inline bool isFixed()
        {
            return fixed;
        }
        inline bool isPlaced()
        {
            return placed;
        }
 
        inline std::string &getName()
        {
            return name;
        }
 
        inline PlacementUnitType getType()
        {
            return unitType;
        }
 
        inline void setWeight(int numCell)
        {
            weight = numCell;
        }
 
        inline int getWeight()
        {
            return weight;
        }
 
        inline unsigned int getId()
        {
            return id;
        }
 
        inline void renewId(int newId)
        {
            id = newId;
        }
 
        inline void setNetsSetPtr(std::vector<PlacementNet *> *_nets)
        {
            nets = _nets;
        }
 
        inline std::vector<PlacementNet *> *getNetsSetPtr()
        {
            return nets;
        }
 
        inline int getUnitsBeDrivenByThisPU()
        {
            if (numUnitsBeDrivenByThisPU >= 0)
                return numUnitsBeDrivenByThisPU;
            numUnitsBeDrivenByThisPU = 0;
            for (auto tmpNet : *nets)
            {
                if (tmpNet->getDriverUnits().size() == 1)
                {
                    if (tmpNet->getDriverUnits()[0] == this)
                    {
                        numUnitsBeDrivenByThisPU += tmpNet->getUnitsBeDriven().size();
                    }
                }
            }
            return numUnitsBeDrivenByThisPU;
        }
 
        inline int getUnitsDriveThisPU()
        {
            if (numUnitsDriveThisPU >= 0)
                return numUnitsDriveThisPU;
            numUnitsDriveThisPU = 0;
            for (auto tmpNet : *nets)
            {
                if (tmpNet->getDriverUnits().size() == 1)
                {
                    if (tmpNet->getDriverUnits()[0] != this)
                    {
                        numUnitsDriveThisPU += 1;
                    }
                }
            }
            return numUnitsDriveThisPU;
        }
 
        inline void addDSP()
        {
            DSPcnt++;
        }
        inline void addBRAM()
        {
            BRAMcnt++;
        }
        inline void addLUTRAM()
        {
            LUTRAMcnt++;
        }
        inline void addLUT()
        {
            LUTcnt++;
        }
        inline void addFF()
        {
            FFcnt++;
        }
        inline void addCARRY()
        {
            CARRYcnt++;
        }
        inline void addMUX()
        {
            MUXcnt++;
        }
        inline bool checkHasDSP()
        {
            return DSPcnt;
        }
        inline bool checkHasBRAM()
        {
            return BRAMcnt;
        }
        inline bool checkHasLUTRAM()
        {
            return LUTRAMcnt;
        }
        inline bool checkHasLUT()
        {
            return LUTcnt;
        }
        inline bool checkHasFF()
        {
            return FFcnt;
        }
        inline bool checkHasCARRY()
        {
            return CARRYcnt;
        }
        inline bool checkHasMUX()
        {
            return MUXcnt;
        }
        inline bool hasRegister()
        {
            return (checkHasFF() || checkHasDSP() || checkHasBRAM() || checkHasLUTRAM());
        }
        inline bool hasLogic()
        {
            return (checkHasFF() || checkHasDSP() || checkHasBRAM() || checkHasLUTRAM() || checkHasCARRY() ||
                    checkHasLUT());
        }
        inline bool isMCLB()
        {
            return LUTRAMcnt;
        }
        inline bool isLCLB()
        {
            return LUTcnt > 0 && CARRYcnt == 0; // LogicCLB with Carray will be handled by macroLegalizer
        }
        inline int getDSPNum()
        {
            return DSPcnt;
        }
        inline int getBRAMNum()
        {
            return BRAMcnt;
        }
        inline int getLUTRAMNum()
        {
            return LUTRAMcnt;
        }
        inline int getLUTNum()
        {
            return LUTcnt;
        }
        inline int getCARRYNum()
        {
            return CARRYcnt;
        }
        inline int getMUXNum()
        {
            return MUXcnt;
        }
        inline void setPacked()
        {
            packed = true;
        }
        inline void resetPacked()
        {
            packed = false;
        }
        inline bool isPacked()
        {
            return packed;
        }
 
        inline std::set<DesignInfo::DesignNet *> &getClockNets()
        {
            return clockNets;
        }
 
      protected:
        std::set<DesignInfo::DesignNet *> clockNets;
 
      private:
        std::string name;
        int id;
        float anchorX = -2000, anchorY = -2000;
        float lastAnchorX = -2000, lastAnchorY = -2000;
        float lastSpreadX = -2000, lastSpreadY = -2000;
        PlacementUnitType unitType;
 
        std::vector<PlacementNet *> *nets;
 
        bool fixed = false;
 
        bool placed = false;
 
        bool locked = false;
        int weight = 1;
 
        int DSPcnt = 0;
        int BRAMcnt = 0;
        int LUTRAMcnt = 0;
        int LUTcnt = 0;
        int FFcnt = 0;
        int CARRYcnt = 0;
        int MUXcnt = 0;
        int numUnitsBeDrivenByThisPU = -1;
        int numUnitsDriveThisPU = -1;
 
        bool packed = false;
    };
 
    class PlacementUnpackedCell : public PlacementUnit
    {
      public:
        PlacementUnpackedCell(std::string name, int id, DesignInfo::DesignCell *cell)
            : PlacementUnit(name, id, PlacementUnitType_UnpackedCell), cell(cell)
        {
            if (cell->isBRAM())
                addBRAM();
            if (cell->isDSP())
                addDSP();
            if (cell->isFF())
                addFF();
            if (cell->isLUTRAM() || cell->originallyIsLUTRAM())
                addLUTRAM();
            if (cell->isLUT())
                addLUT();
            if (cell->isCarry())
                addCARRY();
            if (cell->isMux())
                addMUX();
            clockNets = cell->getClockNets();
        }
        ~PlacementUnpackedCell()
        {
        }
 
        void setLockedAt(std::string _siteName, std::string _BELName, DeviceInfo *deviceInfo, bool lock = true)
        {
            setFixed();
            setPlaced();
            siteName = _siteName;
            BELName = _BELName;
            lockedSite = deviceInfo->getSite(siteName);
            setAnchorLocation(lockedSite->X(), lockedSite->Y());
            lockedSite->setOccupied();
            if (lock)
                setLocked();
        }
 
        inline DeviceInfo::DeviceSite *getLockedSite()
        {
            return lockedSite;
        }
 
        inline DesignInfo::DesignCell *getCell()
        {
            return cell;
        }
 
        inline std::string getFixedBELName()
        {
            return BELName;
        }
 
        inline std::string getFixedSiteName()
        {
            return siteName;
        }
 
      private:
        DesignInfo::DesignCell *cell;
        // DesignInfo::DesignCellType virtualCellType;
        std::string siteName;
        std::string BELName;
        DeviceInfo::DeviceSite *lockedSite = nullptr;
    };
 
    class PlacementMacro : public PlacementUnit
    {
      public:
        enum PlacementMacroType
        {
            PlacementMacroType_LUTFFPair = 0, // LUT-FF pair during  incremental packing
            PlacementMacroType_LUTLUTSeires,  // LUT-LUT pair during  incremental packing
            PlacementMacroType_FFFFPair,      // FF-FF pair during  incremental packing
            PlacementMacroType_HALFCLB,
            PlacementMacroType_LCLB,  // vendor defined primitives, like FFs for system reset, have to be placed in
                                      // SLICEL
            PlacementMacroType_MCLB,  // LUTRAM cells sharing address/data bits or vendor defined primitives have to be
                                      // placed in SLICEM
            PlacementMacroType_CARRY, // chained CARRYs, its directly connected LUTs/FFs and routing BELs.
            PlacementMacroType_DSP,   // Cascaded DSPs
            PlacementMacroType_BRAM,  // Cascaded BRAMs
            PlacementMacroType_MUX7,  // MUXF7, its directly connected LUTs/FFs and routing BELs.
            PlacementMacroType_MUX8,  // MUXF7, its directly connected MUXF7/LUTs/FFs and routing BELs.
            PlacementMacroType_MUX9   // MUXF9, its directly connected MUXF7/MUXF8/LUTs/FFs and routing BELs.
        };
 
        PlacementMacro(std::string name, int id, PlacementMacroType macroType)
            : PlacementUnit(name, id, PlacementUnitType_Macro), macroType(macroType)
        {
            fixedCells.clear();
            cell2IdInMacro.clear();
            cellsInMacro.clear();
            cellSet.clear();
            // siteOccupations.clear();
            top = -10000;
            bottom = 10000;
            left = 10000;
            right = -10000;
        };
        ~PlacementMacro()
        {
        }
 
        inline bool hasCell(DesignInfo::DesignCell *curCell)
        {
            return cellSet.find(curCell) != cellSet.end();
        }
 
        inline void addCell(DesignInfo::DesignCell *curCell, DesignInfo::DesignCellType cellType, float x, float y)
        {
            if (curCell)
            {
                if (curCell->isBRAM())
                    addBRAM();
                if (curCell->isDSP())
                    addDSP();
                if (!curCell->isVirtualCell())
                {
                    if (curCell->isFF())
                        addFF();
                }
                if (curCell->isLUTRAM() || curCell->originallyIsLUTRAM())
                    addLUTRAM();
                if (curCell->isLUT())
                    addLUT();
                if (curCell->isCarry())
                    addCARRY();
                if (curCell->isMux())
                    addMUX();
                curCell->setVirtualType(cellType);
                cell2IdInMacro[curCell] = offsetX.size();
                cellSet.insert(curCell);
                for (auto tmpNet : curCell->getClockNets())
                {
                    clockNets.insert(tmpNet);
                }
            }
            else
            {
                assert(false && "unexpected");
            }
            cellsInMacro.push_back(curCell);
            cells_Type.push_back(cellType);
            offsetX.push_back(x);
            offsetY.push_back(y);
            if (x < left)
                left = x;
            if (x > right)
                right = x;
            if (y < bottom)
                bottom = y;
            if (y > top)
                top = y;
        }
 
        inline DesignInfo::DesignCell *addVirtualCell(std::string virtualCellName, DesignInfo *designInfo,
                                                      DesignInfo::DesignCellType cellType, float x, float y)
        {
            DesignInfo::DesignCell *vCell =
                new DesignInfo::DesignCell(true, virtualCellName, cellType, designInfo->getNumCells());
            designInfo->addCell(vCell); // add the virtual cell to design info for later processing
            cells_Type.push_back(cellType);
            cellsInMacro.push_back(vCell);
            cell2IdInMacro[vCell] = offsetX.size();
            cellSet.insert(vCell);
            offsetX.push_back(x);
            offsetY.push_back(y);
            if (x < left)
                left = x;
            if (x > right)
                right = x;
            if (y < bottom)
                bottom = y;
            if (y > top)
                top = y;
 
            if (vCell->isBRAM())
                addBRAM();
            if (vCell->isDSP())
                addDSP();
            // if (vCell->isFF())
            //     addFF();
            if (vCell->isLUTRAM() || vCell->originallyIsLUTRAM())
                addLUTRAM();
            if (vCell->isLUT())
                addLUT();
            if (vCell->isCarry())
                addCARRY();
            if (vCell->isMux())
                addMUX();
            for (auto tmpNet : vCell->getClockNets())
            {
                clockNets.insert(tmpNet);
            }
            return vCell;
        }
 
        inline void addVirtualCell(DesignInfo *designInfo, DesignInfo::DesignCellType cellType, float x, float y)
        {
            DesignInfo::DesignCell *vCell = new DesignInfo::DesignCell(true, cellType, designInfo->getNumCells());
            designInfo->addCell(vCell); // add the virtual cell to design info for later processing
            cells_Type.push_back(cellType);
            cellsInMacro.push_back(vCell);
            cell2IdInMacro[vCell] = offsetX.size();
            cellSet.insert(vCell);
            offsetX.push_back(x);
            offsetY.push_back(y);
            if (x < left)
                left = x;
            if (x > right)
                right = x;
            if (y < bottom)
                bottom = y;
            if (y > top)
                top = y;
 
            if (vCell->isBRAM())
                addBRAM();
            if (vCell->isDSP())
                addDSP();
            // if (vCell->isFF())
            //     addFF();
            if (vCell->isLUTRAM() || vCell->originallyIsLUTRAM())
                addLUTRAM();
            if (vCell->isLUT())
                addLUT();
            if (vCell->isCarry())
                addCARRY();
            if (vCell->isMux())
                addMUX();
            for (auto tmpNet : vCell->getClockNets())
            {
                clockNets.insert(tmpNet);
            }
        }
 
        inline std::vector<DesignInfo::DesignCell *> &getCells()
        {
            return cellsInMacro;
        }
 
        typedef struct _fixedPlacementInfo_inMacro
        {
            _fixedPlacementInfo_inMacro(DesignInfo::DesignCell *cell, std::string siteName, std::string BELName)
                : cell(cell), siteName(siteName), BELName(BELName)
            {
            }
            DesignInfo::DesignCell *cell;
            std::string siteName;
            std::string BELName;
        } fixedPlacementInfo_inMacro;
 
        inline void addFixedCellInfo(DesignInfo::DesignCell *cell, std::string siteName, std::string BELName)
        {
            fixedCells.emplace_back(cell, siteName, BELName);
        }
 
        inline float getCellOffsetXInMacro(DesignInfo::DesignCell *cell)
        {
            assert(cell2IdInMacro.find(cell) != cell2IdInMacro.end());
            return offsetX[cell2IdInMacro[cell]];
        }
 
        inline float getCellOffsetYInMacro(DesignInfo::DesignCell *cell)
        {
            assert(cell2IdInMacro.find(cell) != cell2IdInMacro.end());
            return offsetY[cell2IdInMacro[cell]];
        }
 
        // bool setFixedCombination(std::vector<DesignInfo::DesignCell *> _cells, std::vector<std::string> _siteNames,
        //                          std::vector<std::string> _BELNames, DeviceInfo *designInfo);
 
        inline void getVirtualCellInfo(int vId, float &x, float &y, DesignInfo::DesignCellType &cellType)
        {
            x = offsetX[vId];
            y = offsetY[vId];
            cellType = cells_Type[vId];
        }
 
        inline DesignInfo::DesignCellType getVirtualCellType(int vId)
        {
            return cells_Type[vId];
        }
 
        inline int getNumOfCells()
        {
            return cells_Type.size();
        }
 
        DesignInfo::DesignCell *getCell(unsigned int id)
        {
            assert(id < cellsInMacro.size());
            return cellsInMacro[id];
        }
 
        inline float getTopOffset()
        {
            return top;
        }
        inline float getBottomOffset()
        {
            return bottom;
        }
        inline float getLeftOffset()
        {
            return left;
        }
        inline float getRightOffset()
        {
            return right;
        }
 
        inline void addOccupiedSite(float siteOffset, float occ)
        {
            //     siteOccupations.push_back(std::pair<float, float>(siteOffset, occ));
        }
        // inline std::vector<std::pair<float, float>> &getOccupiedSiteInfo()
        // {
        //     return siteOccupations;
        // }
 
        inline bool isCellInMacro(DesignInfo::DesignCell *curCell)
        {
            return cellSet.find(curCell) != cellSet.end();
        }
 
        inline PlacementMacroType getMacroType()
        {
            return macroType;
        }
 
        inline std::vector<fixedPlacementInfo_inMacro> &getFixedCellInfoVec()
        {
            return fixedCells;
        }
 
      private:
        // std::vector<std::string> siteNames;
        // std::vector<std::string> BELNames;
        std::set<DesignInfo::DesignCell *> cellSet;
        std::map<DesignInfo::DesignCell *, int> cell2IdInMacro;
        std::vector<DesignInfo::DesignCell *> cellsInMacro;
        std::vector<DesignInfo::DesignCellType>
            cells_Type; // BELTypeOccupation.size()>=realCells.size() because somtime a cell or a connection net
                        // can occupy multiple BEL
        std::vector<float> offsetX, offsetY; // offsetX.size() == BELTypeOccupation.size()
        std::vector<fixedPlacementInfo_inMacro> fixedCells;
        // std::vector<std::pair<float, float>> siteOccupations;
        float left, right, top, bottom;
        PlacementMacroType macroType;
    };
 
    class PlacementNet
    {
      public:
        PlacementNet(DesignInfo::DesignNet *designNet, int id, std::vector<PlacementUnit *> &cellId2PlacementUnitVec,
                     PlacementInfo *placementInfo)
            : designNet(designNet), id(id), placementInfo(placementInfo)
        {
            unitsOfNetPins.clear();
            unitsOfDriverPins.clear();
            unitsOfPinsBeDriven.clear();
            PUSet.clear();
            for (DesignInfo::DesignPin *curPin : designNet->getPins())
            {
                PlacementUnit *tmpPU = cellId2PlacementUnitVec[curPin->getCell()->getElementIdInType()];
                unitsOfNetPins.push_back(tmpPU);
                PUSet.insert(tmpPU);
 
                if (curPin->isOutputPort())
                {
                    unitsOfDriverPins.push_back(tmpPU);
                }
                else
                {
                    unitsOfPinsBeDriven.push_back(tmpPU);
                }
 
                if (tmpPU->getType() == PlacementUnitType_UnpackedCell)
                {
                    pinOffset tmpPinOffset = pinOffset(curPin->getOffsetXInCell(), curPin->getOffsetYInCell());
                    pinOffsetsInUnit.push_back(tmpPinOffset);
                }
                else if (tmpPU->getType() == PlacementUnitType_Macro)
                {
                    PlacementMacro *tmpM = dynamic_cast<PlacementMacro *>(tmpPU);
                    assert(tmpM);
                    pinOffset tmpPinOffset =
                        pinOffset(curPin->getOffsetXInCell() + tmpM->getCellOffsetXInMacro(curPin->getCell()),
                                  curPin->getOffsetYInCell() + tmpM->getCellOffsetYInMacro(curPin->getCell()));
                    pinOffsetsInUnit.push_back(tmpPinOffset);
                }
            }
            leftPuId = rightPuId = topPuId = bottomPuId = -1;
        }
        ~PlacementNet()
        {
        }
 
        typedef struct _pinOffset
        {
            _pinOffset(float x, float y) : x(x), y(y)
            {
            }
            float x = 0.0, y = 0.0;
        } pinOffset;
 
        inline std::vector<PlacementUnit *> &getUnits()
        {
            return unitsOfNetPins;
        }
 
        inline std::vector<PlacementUnit *> &getDriverUnits()
        {
            return unitsOfDriverPins;
        }
 
        inline std::vector<PlacementUnit *> &getUnitsBeDriven()
        {
            return unitsOfPinsBeDriven;
        }
 
        inline DesignInfo::DesignNet *getDesignNet()
        {
            return designNet;
        }
 
        inline int getId()
        {
            return id;
        }
 
        inline std::vector<pinOffset> &getPinOffsetsInUnit()
        {
            return pinOffsetsInUnit;
        }
 
        inline bool updateNetBounds(bool updateX, bool updateY)
        {
            if (updateX)
            {
                leftPUX = 1e5;
                rightPUX = -1e5;
                leftPinX = 1e5;
                rightPinX = -1e5;
                for (unsigned int pinId_net = 0; pinId_net < unitsOfNetPins.size(); pinId_net++)
                {
                    auto tmpPU = unitsOfNetPins[pinId_net];
                    auto tmpPUId = tmpPU->getId();
                    auto tmpPinOffset = pinOffsetsInUnit[pinId_net];
                    float cellX = tmpPU->X();
                    float pinX = tmpPU->X() + tmpPinOffset.x;
                    if (pinX < leftPinX)
                    {
                        leftPinX = pinX;
                        leftPUX = cellX;
                        leftPuId = tmpPUId;
                        leftPinId_net = pinId_net;
                    }
                    if (pinX > rightPinX)
                    {
                        rightPinX = pinX;
                        rightPUX = cellX;
                        rightPuId = tmpPUId;
                        rightPinId_net = pinId_net;
                    }
                }
            }
            if (updateY)
            {
                topPUY = -1e5;
                bottomPUY = 1e5;
                topPinY = -1e5;
                bottomPinY = 1e5;
                for (unsigned int pinId_net = 0; pinId_net < unitsOfNetPins.size(); pinId_net++)
                {
                    auto tmpPU = unitsOfNetPins[pinId_net];
                    auto tmpPUId = tmpPU->getId();
                    auto tmpPinOffset = pinOffsetsInUnit[pinId_net];
                    float cellY = tmpPU->Y();
                    float pinY = tmpPU->Y() + tmpPinOffset.y;
                    if (pinY < bottomPinY)
                    {
                        bottomPinY = pinY;
                        bottomPUY = cellY;
                        bottomPuId = tmpPUId;
                        bottomPinId_net = pinId_net;
                    }
                    if (pinY > topPinY)
                    {
                        topPinY = pinY;
                        topPUY = cellY;
                        topPuId = tmpPUId;
                        topPinId_net = pinId_net;
                    }
                }
            }
            return (updateX && (leftPuId != rightPuId)) || (updateY && (topPuId != bottomPuId));
        }
 
        inline float getHPWL(float y2xRatio)
        {
            return std::fabs(rightPinX - leftPinX) + y2xRatio * std::fabs(topPinY - bottomPinY);
        }
 
        inline float getNewHPWLByTrying(PlacementUnit *curPU, double targetPUX, double targetPUY, float y2xRatio) const
        {
            float tmp_leftX = 1e5;
            float tmp_rightX = -1e5;
            float tmp_topY = -1e5;
            float tmp_bottomY = 1e5;
 
            for (unsigned int pinId_net = 0; pinId_net < unitsOfNetPins.size(); pinId_net++)
            {
                auto tmpPU = unitsOfNetPins[pinId_net];
                auto tmpPinOffset = pinOffsetsInUnit[pinId_net];
                float pinX;
                if (tmpPU == curPU)
                {
                    pinX = targetPUX + tmpPinOffset.x;
                }
                else
                {
                    pinX = tmpPU->X() + tmpPinOffset.x;
                }
                if (pinX < tmp_leftX)
                {
                    tmp_leftX = pinX;
                }
                if (pinX > tmp_rightX)
                {
                    tmp_rightX = pinX;
                }
            }
            for (unsigned int pinId_net = 0; pinId_net < unitsOfNetPins.size(); pinId_net++)
            {
                auto tmpPU = unitsOfNetPins[pinId_net];
                auto tmpPinOffset = pinOffsetsInUnit[pinId_net];
                float pinY;
                if (tmpPU == curPU)
                {
                    pinY = targetPUY + tmpPinOffset.y;
                }
                else
                {
                    pinY = tmpPU->Y() + tmpPinOffset.y;
                }
                if (pinY < tmp_bottomY)
                {
                    tmp_bottomY = pinY;
                }
                if (pinY > tmp_topY)
                {
                    tmp_topY = pinY;
                }
            }
 
            int A_ClockRegionY, A_ClockRegionX;
            placementInfo->getDeviceInfo()->getClockRegionByLocation(tmp_rightX, tmp_bottomY, A_ClockRegionX,
                                                                     A_ClockRegionY);
            std::pair<int, int> A_ClockLocYX(A_ClockRegionY, A_ClockRegionX);
 
            int B_cellClockRegionY, B_cellClockRegionX;
            placementInfo->getDeviceInfo()->getClockRegionByLocation(tmp_leftX, tmp_topY, B_cellClockRegionX,
                                                                     B_cellClockRegionY);
            std::pair<int, int> B_ClockLocYX(B_cellClockRegionY, B_cellClockRegionX);
 
            float clockRegionOverhead = 0;
            // if (B_ClockLocYX != A_ClockLocYX)
            // {
            //     clockRegionOverhead = std::abs(B_cellClockRegionX - A_ClockRegionX) * 15;
            // }
 
            return std::fabs(tmp_rightX - tmp_leftX) + y2xRatio * std::fabs(tmp_topY - tmp_bottomY) +
                   clockRegionOverhead;
        }
 
        inline void updateBound2BoundNetWeight(std::vector<Eigen::Triplet<float>> &objectiveMatrixTripletList,
                                               std::vector<float> &objectiveMatrixDiag,
                                               Eigen::VectorXd &objectiveVector, float generalWeight, float y2xRatio,
                                               bool updateX, bool updateY, bool checkClockRegion = false)
        {
            assert(updateX ^ updateY);
            if (pinOffsetsInUnit.size() <= 1)
                return;
            float w = 2.0 * generalWeight / (float)(pinOffsetsInUnit.size() - 1);
            int nPins = pinOffsetsInUnit.size();
 
            // adopt netDegree Weight from RippeFPGA
            if (nPins < 10)
                w *= 1.00;
            else if (nPins < 20)
                w *= 1.2;
            else if (nPins < 50)
                w *= 1.6;
            else if (nPins < 100)
                w *= 1.8;
            else if (nPins < 200)
                w *= 2.1;
            else
                w *= 2.5;
 
            float tmp_rightX = getRightPinX(), tmp_bottomY = getBottomPinY(), tmp_leftX = getLeftPinX(),
                  tmp_topY = getTopPinY();
 
            int A_ClockRegionY, A_ClockRegionX;
            placementInfo->getDeviceInfo()->getClockRegionByLocation(tmp_rightX, tmp_bottomY, A_ClockRegionX,
                                                                     A_ClockRegionY);
            std::pair<int, int> A_ClockLocYX(A_ClockRegionY, A_ClockRegionX);
 
            int B_cellClockRegionY, B_cellClockRegionX;
            placementInfo->getDeviceInfo()->getClockRegionByLocation(tmp_leftX, tmp_topY, B_cellClockRegionX,
                                                                     B_cellClockRegionY);
            std::pair<int, int> B_ClockLocYX(B_cellClockRegionY, B_cellClockRegionX);
 
            float clockRegionW = 0;
 
            w *= designNet->getOverallEnhanceRatio();
            if (updateX)
            {
                if (checkClockRegion && B_cellClockRegionX != A_ClockRegionX)
                {
                    clockRegionW = 1 + std::abs(B_cellClockRegionX - A_ClockRegionX) * 32 /
                                           (float)(pinOffsetsInUnit.size() - 1) * 0.01;
                    if (clockRegionW > 3)
                        clockRegionW = 3;
                    // w *= clockRegionW;
                }
 
                // add net between left node and right node
                addB2BNet(objectiveMatrixTripletList, objectiveMatrixDiag, objectiveVector, leftPuId, rightPuId,
                          leftPUX, rightPUX, pinOffsetsInUnit[leftPinId_net].x, pinOffsetsInUnit[rightPinId_net].x,
                          !unitsOfNetPins[leftPinId_net]->isFixed(), !unitsOfNetPins[rightPinId_net]->isFixed(),
                          designNet->getPinPairEnhanceRatio(leftPinId_net, rightPinId_net) * w /
                              std::max(minDist, rightPinX - leftPinX));
 
                // add net between internal node and left/right node
                for (unsigned int pinId_net = 0; pinId_net < unitsOfNetPins.size(); pinId_net++)
                {
                    auto tmpPU = unitsOfNetPins[pinId_net];
                    auto tmpPUId = tmpPU->getId();
                    auto tmpPinOffset = pinOffsetsInUnit[pinId_net];
                    float curX = tmpPU->X();
                    bool movable = !tmpPU->isFixed();
                    if (pinId_net != leftPinId_net && pinId_net != rightPinId_net)
                    {
                        addB2BNet(objectiveMatrixTripletList, objectiveMatrixDiag, objectiveVector, tmpPUId, leftPuId,
                                  curX, leftPUX, tmpPinOffset.x, pinOffsetsInUnit[leftPinId_net].x, movable,
                                  !unitsOfNetPins[leftPinId_net]->isFixed(),
                                  designNet->getPinPairEnhanceRatio(pinId_net, leftPinId_net) * w /
                                      std::max(minDist, (curX + tmpPinOffset.x) - leftPinX));
                        addB2BNet(objectiveMatrixTripletList, objectiveMatrixDiag, objectiveVector, tmpPUId, rightPuId,
                                  curX, rightPUX, tmpPinOffset.x, pinOffsetsInUnit[rightPinId_net].x, movable,
                                  !unitsOfNetPins[rightPinId_net]->isFixed(),
                                  designNet->getPinPairEnhanceRatio(pinId_net, rightPinId_net) * w /
                                      std::max(minDist, rightPinX - (curX + tmpPinOffset.x)));
                    }
                }
            }
            if (updateY)
            {
 
                w *= y2xRatio;
 
                // add net between top node and bottom node
                addB2BNet(objectiveMatrixTripletList, objectiveMatrixDiag, objectiveVector, bottomPuId, topPuId,
                          bottomPUY, topPUY, pinOffsetsInUnit[bottomPinId_net].y, pinOffsetsInUnit[topPinId_net].y,
                          !unitsOfNetPins[bottomPinId_net]->isFixed(), !unitsOfNetPins[topPinId_net]->isFixed(),
                          designNet->getPinPairEnhanceRatio(topPinId_net, bottomPinId_net) * w /
                              std::max(minDist, topPinY - bottomPinY));
 
                // add net between internal node and top/bottom node
                for (unsigned int pinId_net = 0; pinId_net < unitsOfNetPins.size(); pinId_net++)
                {
                    auto tmpPU = unitsOfNetPins[pinId_net];
                    auto tmpPUId = tmpPU->getId();
                    auto tmpPinOffset = pinOffsetsInUnit[pinId_net];
                    float curY = tmpPU->Y();
                    bool movable = !tmpPU->isFixed();
                    if (pinId_net != topPinId_net && pinId_net != bottomPinId_net)
                    {
                        addB2BNet(objectiveMatrixTripletList, objectiveMatrixDiag, objectiveVector, tmpPUId, bottomPuId,
                                  curY, bottomPUY, tmpPinOffset.y, pinOffsetsInUnit[bottomPinId_net].y, movable,
                                  !unitsOfNetPins[bottomPinId_net]->isFixed(),
                                  designNet->getPinPairEnhanceRatio(pinId_net, bottomPinId_net) * w /
                                      std::max(minDist, (curY + tmpPinOffset.y) - bottomPinY));
                        addB2BNet(objectiveMatrixTripletList, objectiveMatrixDiag, objectiveVector, tmpPUId, topPuId,
                                  curY, topPUY, tmpPinOffset.y, pinOffsetsInUnit[topPinId_net].y, movable,
                                  !unitsOfNetPins[topPinId_net]->isFixed(),
                                  designNet->getPinPairEnhanceRatio(pinId_net, topPinId_net) * w /
                                      std::max(minDist, topPinY - (curY + tmpPinOffset.y)));
                    }
                }
            }
        }
 
        inline void addPseudoNet_enhancePin2Pin(std::vector<Eigen::Triplet<float>> &objectiveMatrixTripletList,
                                                std::vector<float> &objectiveMatrixDiag,
                                                Eigen::VectorXd &objectiveVector, float generalWeight, float y2xRatio,
                                                bool updateX, bool updateY, int PUIdA, int PUIdB, int pinIdA_net,
                                                int pinIdB_net)
        {
            float w = generalWeight;
 
            if (updateX)
            {
                // add net between left node and right node
                addB2BNet(objectiveMatrixTripletList, objectiveMatrixDiag, objectiveVector, PUIdA, PUIdB,
                          unitsOfNetPins[pinIdA_net]->X(), unitsOfNetPins[pinIdB_net]->X(),
                          pinOffsetsInUnit[pinIdA_net].x, pinOffsetsInUnit[pinIdB_net].x,
                          !unitsOfNetPins[pinIdA_net]->isFixed(), !unitsOfNetPins[pinIdB_net]->isFixed(), w);
            }
            if (updateY)
            {
                w *= y2xRatio;
 
                // add net between top node and bottom node
                addB2BNet(objectiveMatrixTripletList, objectiveMatrixDiag, objectiveVector, PUIdA, PUIdB,
                          unitsOfNetPins[pinIdA_net]->Y(), unitsOfNetPins[pinIdB_net]->Y(),
                          pinOffsetsInUnit[pinIdA_net].y, pinOffsetsInUnit[pinIdB_net].y,
                          !unitsOfNetPins[pinIdA_net]->isFixed(), !unitsOfNetPins[pinIdB_net]->isFixed(), w);
            }
        }
 
        void drawNet(float generalWeight = 1.0);
 
        inline void addB2BNet(std::vector<Eigen::Triplet<float>> &objectiveMatrixTripletList,
                              std::vector<float> &objectiveMatrixDiag, Eigen::VectorXd &objectiveVector, int puId0,
                              int puId1, float pos0, float pos1, float pinOffset0, float pinOffset1, bool movable0,
                              bool movable1, float w)
        {
            // min_x 0.5 * x'Px + q'x
            // s.t.  l <= Ax <= u
            if (puId0 == puId1)
                return;
            if (movable0 && movable1)
            {
                // x0^2 + x1^2 - 2x0x1 + 2(x0c-x1c)x0 + 2(x1c-x0c)x1
                // objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId0, puId0, w));
                // objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId1, puId1, w));
                objectiveMatrixDiag[puId0] += w;
                objectiveMatrixDiag[puId1] += w;
                objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId0, puId1, -w));
                objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId1, puId0, -w));
                if (fabs(pinOffset0) > eps || fabs(pinOffset1) > eps)
                {
                    // 2(x0c-x1c)x0 + 2(x1c-x0c)x1
                    objectiveVector[puId0] += w * (pinOffset0 - pinOffset1);
                    objectiveVector[puId1] += w * (pinOffset1 - pinOffset0);
                }
            }
            else if (movable0)
            {
                // x0^2 - 2x0x1 + 2(x0c-x1c)x0
                // objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId0, puId0, w));
                objectiveMatrixDiag[puId0] += w;
                objectiveVector[puId0] += -w * pos1;
                if (fabs(pinOffset0) > eps || fabs(pinOffset1) > eps)
                {
                    // 2(x0c-x1c)x0
                    objectiveVector[puId0] += w * (pinOffset0 - pinOffset1);
                }
            }
            else if (movable1)
            {
                // x1^2 - 2x0x1 + 2(x1c-x0c)x1
                // objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId1, puId1, w));
                objectiveMatrixDiag[puId1] += w;
                objectiveVector[puId1] += -w * pos0;
                if (fabs(pinOffset0) > eps || fabs(pinOffset1) > eps)
                {
                    // 2(x1c-x0c)x1
                    objectiveVector[puId1] += w * (pinOffset1 - pinOffset0);
                }
            }
        }
 
        inline std::set<PlacementUnit *> &getPUSet()
        {
            return PUSet;
        }
 
        inline float getLeftPinX()
        {
            assert(leftPuId >= 0);
            return leftPinX;
        }
 
        inline float getRightPinX()
        {
            assert(rightPuId >= 0);
            return rightPinX;
        }
 
        inline float getTopPinY()
        {
            assert(topPuId >= 0);
            return topPinY;
        }
 
        inline float getBottomPinY()
        {
            assert(bottomPuId >= 0);
            return bottomPinY;
        }
 
        inline int getLeftPUId()
        {
            assert(leftPuId >= 0);
            return leftPuId;
        }
 
        inline int getRightPUId()
        {
            assert(rightPuId >= 0);
            return rightPuId;
        }
 
        inline int getTopPUId()
        {
            assert(topPuId >= 0);
            return topPuId;
        }
 
        inline int getBottomPUId()
        {
            assert(bottomPuId >= 0);
            return bottomPuId;
        }
 
        inline bool isGlobalClock()
        {
            assert(designNet);
            return designNet->checkIsGlobalClock();
        }
 
      private:
        DesignInfo::DesignNet *designNet = nullptr;
        std::vector<PlacementUnit *> unitsOfNetPins;
        std::vector<PlacementUnit *> unitsOfDriverPins;
        std::vector<PlacementUnit *> unitsOfPinsBeDriven;
        std::vector<pinOffset> pinOffsetsInUnit;
        std::set<PlacementUnit *> PUSet;
 
        int id;
        PlacementInfo *placementInfo = nullptr;
        float leftPUX, rightPUX, topPUY, bottomPUY;
        float leftPinX, rightPinX, topPinY, bottomPinY;
        unsigned int leftPuId, rightPuId, topPuId, bottomPuId;
        unsigned int leftPinId_net, rightPinId_net, topPinId_net, bottomPinId_net;
        float eps = 1e-5;
        float minDist = 1;
    };
 
    class ClusterUnit
    {
      public:
        ClusterUnit(int id) : id(id)
        {
            PUs.clear();
            totalWeight = 0;
            totalBRAMNum = 0;
            totalDSPNum = 0;
        }
        ~ClusterUnit(){};
        inline int getWeight()
        {
            return totalWeight;
        };
        inline int getBRAMNum()
        {
            return totalBRAMNum;
        };
        inline int getDSPNum()
        {
            return totalDSPNum;
        };
 
        inline void addPlacementUnit(PlacementInfo::PlacementUnit *curPU)
        {
            PUs.push_back(curPU);
            totalWeight += curPU->getWeight();
            totalBRAMNum += curPU->getBRAMNum();
            totalDSPNum += curPU->getDSPNum();
        }
 
        inline std::vector<PlacementInfo::PlacementUnit *> &getUnits()
        {
            return PUs;
        }
 
        inline int getId()
        {
            return id;
        }
 
      private:
        std::vector<PlacementInfo::PlacementUnit *> PUs;
        int totalWeight, totalBRAMNum, totalDSPNum;
        int id;
    };
 
    class ClusterNet
    {
      public:
        ClusterNet(int id) : id(id)
        {
            clusterUnits.clear();
        }
        ~ClusterNet(){};
        inline std::vector<ClusterUnit *> &getUnits()
        {
            return clusterUnits;
        }
 
        inline int getId()
        {
            return id;
        }
 
        inline void addClusterUnit(ClusterUnit *tmpCU)
        {
            clusterUnits.push_back(tmpCU);
        }
 
      private:
        std::vector<ClusterUnit *> clusterUnits;
        int id;
    };
 
    class PlacementSiteBinInfo
    {
      public:
        PlacementSiteBinInfo(float leftX, float rightX, float bottomY, float topY, int row, int column)
            : leftX(leftX), rightX(rightX), topY(topY), bottomY(bottomY), row(row), column(column)
 
        {
            correspondingSites.clear();
            macros.clear();
        }
 
        void addSiteIntoBin(DeviceInfo::DeviceSite *curSite);
 
        ~PlacementSiteBinInfo()
        {
            correspondingSites.clear();
            macros.clear();
        }
 
        inline bool inRange(float x, float y)
        {
            return (x <= rightX && x > leftX && y <= topY && y > bottomY);
        }
 
        inline bool inRangeY(float y)
        {
            return (y <= topY && y > bottomY);
        }
 
        inline void addMacroSite(PlacementMacro *curMacro, float occupationAdded)
        {
            if (curMacro)
                macros.push_back(curMacro);
            utilization += occupationAdded;
        }
 
        inline void reset()
        {
            macros.clear();
            utilization = 0;
        }
 
        inline std::vector<PlacementMacro *> &getMacros()
        {
            return macros;
        }
 
        inline float getUtilizationRate()
        {
            if (capacity == 0)
                return utilization / 0.01;
            assert(capacity != 0);
            return (float)binShrinkRatio * utilization / capacity;
        }
 
        inline float getUtilization()
        {
            return (float)utilization;
        }
 
        inline float getCapacity()
        {
            return (float)capacity / binShrinkRatio;
        }
 
        inline bool isOverflow()
        {
            if (capacity == 0)
            {
                if (utilization == 0)
                    return false;
                else
                    return true;
            }
            assert(capacity != 0);
            return ((float)binShrinkRatio * utilization / capacity) > 1.00 + eps;
        }
 
        inline bool canAddMore(int BELAmo)
        {
            if (capacity == 0)
                return false;
            return ((float)binShrinkRatio * (utilization + BELAmo) / capacity) <= 1.00 + eps;
        }
 
        inline void setYX(int i, int j)
        {
            row = i;
            column = j;
        }
 
        inline int Y()
        {
            return row;
        }
        inline int X()
        {
            return column;
        }
 
      private:
        std::vector<DeviceInfo::DeviceSite *> correspondingSites;
        std::vector<PlacementMacro *> macros;
        int capacity = 0;
        float utilization = 0;
        float binShrinkRatio = 1.0;
        float leftX;
        float rightX;
        float topY;
        float bottomY;
        float eps = 1e-5;
        int row;
        int column;
    };
 
    PlacementInfo(DesignInfo *designInfo, DeviceInfo *deviceInfo, std::map<std::string, std::string> &JSONCfg);
    ~PlacementInfo()
    {
        delete compatiblePlacementTable;
        for (auto typeGrid : SharedBELTypeBinGrid)
            for (auto curRow : typeGrid)
                for (auto curBin : curRow)
                    delete curBin;
        for (auto curRow : siteGridForMacros)
            for (auto curBin : curRow)
                delete curBin;
        for (auto pn : placementNets)
            delete pn;
    }
 
    void printStat(bool verbose = false);
 
    CompatiblePlacementTable *loadCompatiblePlacementTable(std::string cellType2fixedAmoFileName,
                                                           std::string cellType2sharedCellTypeFileName,
                                                           std::string sharedCellType2BELtypeFileName)
    {
        return new CompatiblePlacementTable(cellType2fixedAmoFileName, cellType2sharedCellTypeFileName,
                                            sharedCellType2BELtypeFileName, designInfo, deviceInfo);
    }
 
    inline CompatiblePlacementTable *getCompatiblePlacementTable()
    {
        return compatiblePlacementTable;
    }
 
    void setBELTypeForCells(DesignInfo *designInfo)
    {
        compatiblePlacementTable->setBELTypeForCells(designInfo);
    }
 
    float getMinXFromSites(std::vector<DeviceInfo::DeviceSite *> &sites);
 
    float getMinYFromSites(std::vector<DeviceInfo::DeviceSite *> &sites);
 
    float getMaxXFromSites(std::vector<DeviceInfo::DeviceSite *> &sites);
 
    float getMaxYFromSites(std::vector<DeviceInfo::DeviceSite *> &sites);
 
    void createGridBins(float binWidth, float binHeight);
    void createSiteBinGrid();
 
    void reloadNets();
 
    void updateLongPaths();
 
    void verifyDeviceForDesign();
 
    inline std::vector<PlacementUnit *> &getPlacementUnits()
    {
        return placementUnits;
    }
    inline std::vector<PlacementMacro *> &getPlacementMacros()
    {
        return placementMacros;
    }
    inline std::vector<PlacementUnit *> &getFixedPlacementUnits()
    {
        return fixedPlacementUnits;
    }
    inline std::vector<PlacementNet *> &getPlacementNets()
    {
        return placementNets;
    }
    inline std::set<DesignInfo::DesignCell *> &getCellInMacros()
    {
        return cellInMacros;
    }
    inline std::map<int, PlacementUnit *> &getCellId2PlacementUnit()
    {
        return cellId2PlacementUnit;
    }
    inline std::vector<PlacementUnit *> &getCellId2PlacementUnitVec()
    {
        return cellId2PlacementUnitVec;
    }
    inline std::vector<PlacementUnpackedCell *> &getPlacementUnpackedCells()
    {
        return placementUnpackedCells;
    }
    inline int getNumCells()
    {
        return designInfo->getNumCells();
    }
 
    inline float getGlobalMaxX()
    {
        return globalMaxX;
    }
 
    inline float getGlobalMaxY()
    {
        return globalMaxY;
    }
 
    inline float getGlobalMinX()
    {
        return globalMinX;
    }
 
    inline float getGlobalMinY()
    {
        return globalMinY;
    }
 
    inline float getGlobalBinMaxLocX()
    {
        return endX;
    }
 
    inline float getGlobalBinMaxLocY()
    {
        return endY;
    }
 
    inline float getGlobalBinMinLocX()
    {
        return startX;
    }
 
    inline float getGlobalBinMinLocY()
    {
        return startY;
    }
 
    inline float getDeviceMaxEdgeLength()
    {
        return std::max(endX - startX, endY - startY);
    }
 
    inline std::vector<int> &getPotentialBELTypeIDs(DesignInfo::DesignCell *cell)
    {
        return compatiblePlacementTable->getPotentialBELTypeIDs(cell);
    }
 
    inline std::vector<int> &getPotentialBELTypeIDs(DesignInfo::DesignCellType cellType)
    {
        return compatiblePlacementTable->getPotentialBELTypeIDs(cellType);
    }
 
    inline int getSharedBELTypeId(std::string tmpStr)
    {
        return compatiblePlacementTable->getSharedBELTypeId(tmpStr);
    }
 
    inline float getActualOccupation(DesignInfo::DesignCell *cell)
    {
        return compatiblePlacementTable->getActualOccupation(cell);
    }
 
    inline float getInflateRatio(DesignInfo::DesignCell *cell)
    {
        return compatiblePlacementTable->getInflateRatio(cell);
    }
 
    inline std::vector<float> &getcellId2Occupation()
    {
        return compatiblePlacementTable->getcellId2Occupation();
    }
 
    inline float getOccupation(DesignInfo::DesignCellType cellType)
    {
        return compatiblePlacementTable->getOccupation(cellType);
    }
 
    inline float getActualOccupationByCellId(int id)
    {
        return compatiblePlacementTable->getActualOccupationByCellId(id);
    }
 
    inline std::vector<DesignInfo::DesignCell *> *
    findNeiborLUTFFsFromBinGrid(DesignInfo::DesignCell *curCell, float displacementUpperbound, int minNumNeighbor = 10)
    {
        // please note that the input DesignCell is only used to find the corresponding binGrid for site search.
        bool findLUT = curCell->isLUT();
        float targetX = cellId2location[curCell->getCellId()].X;
        float targetY = cellId2location[curCell->getCellId()].Y;
        std::vector<DesignInfo::DesignCell *> *res = new std::vector<DesignInfo::DesignCell *>();
        res->clear();
 
        int binIdX, binIdY;
        getGridXY(targetX, targetY, binIdX, binIdY);
 
        assert(binIdY >= 0);
        assert((unsigned int)binIdY < LUTFFBinGrid.size());
        assert(binIdX >= 0);
        assert((unsigned int)binIdX < LUTFFBinGrid[binIdY].size());
        assert(LUTFFBinGrid[binIdY][binIdX]->inRange(targetX, targetY));
 
        std::queue<std::pair<int, int>> binXYqueue;
        std::set<std::pair<int, int>> reachedBinXYs;
        binXYqueue.emplace(binIdX, binIdY);
        reachedBinXYs.emplace(binIdX, binIdY);
 
        bool findItself = false;
 
        while (binXYqueue.size() > 0)
        {
            std::pair<int, int> curXY = binXYqueue.front();
            binXYqueue.pop();
            int curbinIdX = curXY.first, curbinIdY = curXY.second;
 
            PlacementInfo::PlacementBinInfo *curBin = LUTFFBinGrid[curbinIdY][curbinIdX];
            float bin2TargetXYDistance = curBin->getManhattanDistanceTo(targetX, targetY);
            if (bin2TargetXYDistance > displacementUpperbound)
                continue;
            for (auto tmpCell : curBin->getCells())
            {
                if ((tmpCell->isLUT() && findLUT) || (tmpCell->isFF() && !findLUT))
                {
                    float tmpX = cellId2location[tmpCell->getCellId()].X;
                    float tmpY = cellId2location[tmpCell->getCellId()].Y;
                    float tmpPUDis = fabs(targetX - tmpX) + y2xRatio * fabs(targetY - tmpY);
                    if (tmpPUDis <= displacementUpperbound)
                    {
                        if (tmpCell == curCell)
                        {
                            findItself = true;
                        }
                        res->push_back(tmpCell);
                    }
                }
            }
            assert(findItself);
            for (int nextY = curbinIdY - 1; nextY <= curbinIdY + 1; nextY++)
            {
                for (int nextX = curbinIdX - 1; nextX <= curbinIdX + 1; nextX++)
                {
                    if (!(nextY >= 0))
                        continue;
                    if (!((unsigned int)nextY < LUTFFBinGrid.size()))
                        continue;
                    if (!(nextX >= 0))
                        continue;
                    if (!((unsigned int)nextX < LUTFFBinGrid[binIdY].size()))
                        continue;
                    PlacementInfo::PlacementBinInfo *nextBin = LUTFFBinGrid[nextY][nextX];
                    float nextBin2TargetXYDistance = nextBin->getManhattanDistanceTo(targetX, targetY);
                    if (nextBin2TargetXYDistance > displacementUpperbound)
                        continue;
                    std::pair<int, int> nextXY(nextX, nextY);
                    if (reachedBinXYs.find(nextXY) == reachedBinXYs.end())
                    {
                        reachedBinXYs.insert(nextXY);
                        binXYqueue.push(nextXY);
                    }
                }
            }
        }
 
        assert(findItself);
        return res;
    }
 
    inline std::vector<std::vector<PlacementBinInfo *>> &getBinGrid(unsigned int BELTypeId)
    {
        assert(BELTypeId < SharedBELTypeBinGrid.size());
        return SharedBELTypeBinGrid[BELTypeId];
    }
 
    inline std::vector<std::vector<std::vector<PlacementBinInfo *>>> &getBinGrid()
    {
        return SharedBELTypeBinGrid;
    }
 
    inline std::vector<std::vector<PlacementSiteBinInfo *>> &getSiteBinGrid()
    {
        return siteGridForMacros;
    }
 
    inline PlacementUnit *getPlacementUnitByCell(DesignInfo::DesignCell *curCell)
    {
        assert(curCell);
        assert((unsigned int)curCell->getCellId() < cellId2PlacementUnitVec.size());
        return cellId2PlacementUnitVec[curCell->getCellId()];
    }
 
    inline PlacementUnit *getPlacementUnitByCellId(int cellId)
    {
        assert(cellId >= 0);
        assert((unsigned int)cellId < cellId2PlacementUnitVec.size());
        return cellId2PlacementUnitVec[cellId];
    }
 
    inline PlacementNet *getPlacementNetByDesignNetId(int netId)
    {
        assert((unsigned int)netId < designNetId2PlacementNet.size());
        return designNetId2PlacementNet[netId];
    }
 
    inline void addB2BNetInPlacementInfo(std::vector<Eigen::Triplet<float>> &objectiveMatrixTripletList,
                                         std::vector<float> &objectiveMatrixDiag, Eigen::VectorXd &objectiveVector,
                                         int puId0, int puId1, float pos0, float pos1, float pinOffset0,
                                         float pinOffset1, bool movable0, bool movable1, float w)
    {
        // min_x 0.5 * x'Px + q'x
        // s.t.  l <= Ax <= u
        if (puId0 == puId1)
            return;
        if (movable0 && movable1)
        {
            // x0^2 + x1^2 - 2x0x1 + 2(x0c-x1c)x0 + 2(x1c-x0c)x1
            // objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId0, puId0, w));
            // objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId1, puId1, w));
            objectiveMatrixDiag[puId0] += w;
            objectiveMatrixDiag[puId1] += w;
            objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId0, puId1, -w));
            objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId1, puId0, -w));
            if (fabs(pinOffset0) > eps || fabs(pinOffset1) > eps)
            {
                // 2(x0c-x1c)x0 + 2(x1c-x0c)x1
                objectiveVector[puId0] += w * (pinOffset0 - pinOffset1);
                objectiveVector[puId1] += w * (pinOffset1 - pinOffset0);
            }
        }
        else if (movable0)
        {
            // x0^2 - 2x0x1 + 2(x0c-x1c)x0
            // objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId0, puId0, w));
            objectiveMatrixDiag[puId0] += w;
            objectiveVector[puId0] += -w * pos1;
            if (fabs(pinOffset0) > eps || fabs(pinOffset1) > eps)
            {
                // 2(x0c-x1c)x0
                objectiveVector[puId0] += w * (pinOffset0 - pinOffset1);
            }
        }
        else if (movable1)
        {
            // x1^2 - 2x0x1 + 2(x1c-x0c)x1
            // objectiveMatrixTripletList.push_back(Eigen::Triplet<float>(puId1, puId1, w));
            objectiveMatrixDiag[puId1] += w;
            objectiveVector[puId1] += -w * pos0;
            if (fabs(pinOffset0) > eps || fabs(pinOffset1) > eps)
            {
                // 2(x1c-x0c)x1
                objectiveVector[puId1] += w * (pinOffset1 - pinOffset0);
            }
        }
    }
 
    inline void addPseudoNetsInPlacementInfo(std::vector<Eigen::Triplet<float>> &objectiveMatrixTripletList,
                                             std::vector<float> &objectiveMatrixDiag, Eigen::VectorXd &objectiveVector,
                                             PlacementUnit *tmpPU, float targetLoc, float pseudoWeight, float y2xRatio,
                                             bool updateX, bool updateY)
    {
        assert(updateX ^ updateY);
        if (updateY)
        {
            pseudoWeight *= y2xRatio;
        }
        bool movable = !tmpPU->isFixed();
        if (movable)
        {
            addB2BNetInPlacementInfo(objectiveMatrixTripletList, objectiveMatrixDiag, objectiveVector, tmpPU->getId(),
                                     -1, targetLoc, targetLoc, 0, 0, true, false, pseudoWeight);
        }
    }
 
    void updateCells2PlacementUnits();
 
    void updateElementBinGrid();
 
    void adjustLUTFFUtilization_Routability(bool enfore);
 
    void adjustLUTFFUtilization_Routability_Reset();
 
    void adjustLUTFFUtilization_Packablity(float neighborDisplacementUpperbound, bool enfore);
 
    void adjustLUTFFUtilization(float neighborDisplacementUpperbound, bool enfore = false);
 
    void adjustLUTFFUtilization_Clocking();
 
    void resetElementBinGrid();
 
    void updateSiteBinGrid();
 
    void resetSiteBinGrid();
 
    inline DesignInfo *getDesignInfo()
    {
        return designInfo;
    }
 
    inline DeviceInfo *getDeviceInfo()
    {
        return deviceInfo;
    }
 
    inline PlacementTimingInfo *getTimingInfo()
    {
        return simplePlacementTimingInfo;
    }
 
    inline std::string getBELType2FalseBELType(std::string curBELType)
    {
        return deviceInfo->getBELType2FalseBELType(curBELType);
    }
 
    inline void getGridXY(float cellX, float cellY, int &binIdX, int &binIdY)
    {
 
        float coord_offsetX = cellX - startX;
        float coord_offsetY = cellY - startY;
        binIdX = static_cast<int>((coord_offsetX) / binWidth);
        binIdY = static_cast<int>((coord_offsetY) / binHeight);
        if (binIdY < 0)
            binIdY = 0;
        if (binIdX < 0)
            binIdX = 0;
    }
 
    inline void legalizeXYInArea(PlacementUnit *curPU, float &fX, float &fY)
    {
        if (curPU->getType() == PlacementUnitType_UnpackedCell)
        {
            fX = std::max(globalMinX + eps, (std::min(fX, globalMaxX - eps)));
            fY = std::max(globalMinY + eps, (std::min(fY, globalMaxY - eps)));
        }
        else if (auto curMacro = dynamic_cast<PlacementMacro *>(curPU))
        {
            if (fY + curMacro->getTopOffset() > globalMaxY - eps)
            {
                fY = (globalMaxY - 2 * eps) - curMacro->getTopOffset();
            }
            else if (fY + curMacro->getBottomOffset() < globalMinY + eps)
            {
                fY = (globalMinY + 2 * eps) - curMacro->getBottomOffset();
            }
 
            if (fX + curMacro->getRightOffset() > globalMaxX - eps)
            {
                fX = (globalMaxX - 2 * eps) - curMacro->getRightOffset();
            }
            else if (fX + curMacro->getLeftOffset() < globalMinX + eps)
            {
                fX = (globalMinX + 2 * eps) - curMacro->getLeftOffset();
            }
        }
        else
        {
            assert(false && "wrong placement unit type");
        }
    }
 
    inline void enforceLegalizeXYInArea(PlacementUnit *curPU)
    {
        float fX = curPU->X();
        float fY = curPU->Y();
        if (curPU->getType() == PlacementUnitType_UnpackedCell)
        {
            fX = std::max(globalMinX + eps, (std::min(fX, globalMaxX - eps)));
            fY = std::max(globalMinY + eps, (std::min(fY, globalMaxY - eps)));
        }
        else if (auto curMacro = dynamic_cast<PlacementMacro *>(curPU))
        {
            if (fY + curMacro->getTopOffset() > globalMaxY - eps)
            {
                fY = (globalMaxY - 2 * eps) - curMacro->getTopOffset();
            }
            else if (fY + curMacro->getBottomOffset() < globalMinY + eps)
            {
                fY = (globalMinY + 2 * eps) - curMacro->getBottomOffset();
            }
 
            if (fX + curMacro->getRightOffset() > globalMaxX - eps)
            {
                fX = (globalMaxX - 2 * eps) - curMacro->getRightOffset();
            }
            else if (fX + curMacro->getLeftOffset() < globalMinX + eps)
            {
                fX = (globalMinX + 2 * eps) - curMacro->getLeftOffset();
            }
        }
        else
        {
            assert(false && "wrong placement unit type");
        }
        if (fX != curPU->X() || fY != curPU->Y())
        {
            curPU->setAnchorLocationAndForgetTheOriginalOne(fX, fY);
        }
    }
 
    inline bool isLegalLocation(DesignInfo::DesignCell *curCell, float targetX, float targetY)
    {
        auto curPU = cellId2PlacementUnit[curCell->getCellId()];
 
        if (curPU->getType() == PlacementUnitType_UnpackedCell)
        {
            float fX = targetX;
            float fY = targetY;
            fX = std::max(globalMinX + eps, (std::min(fX, globalMaxX - eps)));
            fY = std::max(globalMinY + eps, (std::min(fY, globalMaxY - eps)));
            return (std::fabs(fX - targetX) + std::fabs(fY - targetY)) < eps;
        }
        else if (auto curMacro = dynamic_cast<PlacementMacro *>(curPU))
        {
            float offsetX = curMacro->getCellOffsetXInMacro(curCell);
            float offsetY = curMacro->getCellOffsetYInMacro(curCell);
            float fX = targetX - offsetX;
            float fY = targetY - offsetY;
            if (fY + curMacro->getTopOffset() > globalMaxY - eps)
            {
                fY = (globalMaxY - 2 * eps) - curMacro->getTopOffset();
            }
            else if (fY + curMacro->getBottomOffset() < globalMinY + eps)
            {
                fY = (globalMinY + 2 * eps) - curMacro->getBottomOffset();
            }
 
            if (fX + curMacro->getRightOffset() > globalMaxX - eps)
            {
                fX = (globalMaxX - 2 * eps) - curMacro->getRightOffset();
            }
            else if (fX + curMacro->getLeftOffset() < globalMinX + eps)
            {
                fX = (globalMinX + 2 * eps) - curMacro->getLeftOffset();
            }
            return (std::fabs(fX + offsetX - targetX) + std::fabs(fY + offsetY - targetY)) < eps;
        }
        else
        {
            assert(false && "should not reach here");
            return false;
        }
    }
 
    inline bool isLegalLocation(PlacementUnit *curPU, float targetX, float targetY)
    {
        if (curPU->getType() == PlacementUnitType_UnpackedCell)
        {
            float fX = targetX;
            float fY = targetY;
            fX = std::max(globalMinX + eps, (std::min(fX, globalMaxX - eps)));
            fY = std::max(globalMinY + eps, (std::min(fY, globalMaxY - eps)));
            return (std::fabs(fX - targetX) + std::fabs(fY - targetY)) < eps;
        }
        else if (auto curMacro = dynamic_cast<PlacementMacro *>(curPU))
        {
            float fX = targetX;
            float fY = targetY;
            if (fY + curMacro->getTopOffset() > globalMaxY - eps)
            {
                fY = (globalMaxY - 2 * eps) - curMacro->getTopOffset();
            }
            else if (fY + curMacro->getBottomOffset() < globalMinY + eps)
            {
                fY = (globalMinY + 2 * eps) - curMacro->getBottomOffset();
            }
 
            if (fX + curMacro->getRightOffset() > globalMaxX - eps)
            {
                fX = (globalMaxX - 2 * eps) - curMacro->getRightOffset();
            }
            else if (fX + curMacro->getLeftOffset() < globalMinX + eps)
            {
                fX = (globalMinX + 2 * eps) - curMacro->getLeftOffset();
            }
            return (std::fabs(fX - targetX) + std::fabs(fY - targetY)) < eps;
        }
        else
        {
            assert(false && "should not reach here");
            return false;
        }
    }
 
    inline void getPULocationByCellLocation(DesignInfo::DesignCell *curCell, float targetX, float targetY, float &PUX,
                                            float &PUY)
    {
        auto curPU = cellId2PlacementUnit[curCell->getCellId()];
 
        if (curPU->getType() == PlacementUnitType_UnpackedCell)
        {
            float fX = targetX;
            float fY = targetY;
            fX = std::max(globalMinX + eps, (std::min(fX, globalMaxX - eps)));
            fY = std::max(globalMinY + eps, (std::min(fY, globalMaxY - eps)));
            PUX = fX;
            PUY = fY;
        }
        else if (auto curMacro = dynamic_cast<PlacementMacro *>(curPU))
        {
            float offsetX = curMacro->getCellOffsetXInMacro(curCell);
            float offsetY = curMacro->getCellOffsetYInMacro(curCell);
            float fX = targetX - offsetX;
            float fY = targetY - offsetY;
            if (fY + curMacro->getTopOffset() > globalMaxY - eps)
            {
                fY = (globalMaxY - 2 * eps) - curMacro->getTopOffset();
            }
            else if (fY + curMacro->getBottomOffset() < globalMinY + eps)
            {
                fY = (globalMinY + 2 * eps) - curMacro->getBottomOffset();
            }
 
            if (fX + curMacro->getRightOffset() > globalMaxX - eps)
            {
                fX = (globalMaxX - 2 * eps) - curMacro->getRightOffset();
            }
            else if (fX + curMacro->getLeftOffset() < globalMinX + eps)
            {
                fX = (globalMinX + 2 * eps) - curMacro->getLeftOffset();
            }
            PUX = fX;
            PUY = fY;
        }
        else
        {
            PUX = -1;
            PUY = -1;
            assert(false && "should not reach here.");
        }
    }
 
    typedef struct Location
    {
        float X = -10;
        float Y = -10;
    } Location;
 
    inline std::vector<Location> &getCellId2location()
    {
        return cellId2location;
    }
 
    inline std::vector<Location> &getPinId2location()
    {
        return pinId2location;
    }
 
    inline float getBinGridW()
    {
        return binWidth;
    }
 
    inline float getBinGridH()
    {
        return binHeight;
    }
 
    typedef struct CellBinInfo
    {
        int sharedTypeId = -1;
        int X = -1;
        int Y = -1;
        float occupation = -1;
    } CellBinInfo;
 
    inline void setPULegalXY(std::map<PlacementInfo::PlacementUnit *, float> &PU2X,
                             std::map<PlacementInfo::PlacementUnit *, float> &PU2Y)
    {
        for (auto tmpPair : PU2X) // only update elements in PU2X and PU2Y
        {
            PULegalXY.first[tmpPair.first] = tmpPair.second;
        }
        for (auto tmpPair : PU2Y)
        {
 
            PULegalXY.second[tmpPair.first] = tmpPair.second;
        }
    }
 
    inline void
    setPULegalSite(std::map<PlacementInfo::PlacementUnit *, std::vector<DeviceInfo::DeviceSite *>> &PU2Sites)
    {
        for (auto tmpPair : PU2Sites) // only update elements in PU2X and PU2Y
        {
            PU2LegalSites[tmpPair.first] = tmpPair.second;
        }
    }
 
    inline std::map<PlacementInfo::PlacementUnit *, std::vector<DeviceInfo::DeviceSite *>> &getPULegalSite()
    {
        return PU2LegalSites;
    }
 
    inline std::pair<std::map<PlacementInfo::PlacementUnit *, float>, std::map<PlacementInfo::PlacementUnit *, float>> &
    getPULegalXY()
    {
        return PULegalXY;
    }
 
    void resetPULegalInformation()
    {
        PULegalXY.first = std::map<PlacementInfo::PlacementUnit *, float>();
        PULegalXY.second = std::map<PlacementInfo::PlacementUnit *, float>();
        PU2LegalSites.clear();
    }
 
    inline void deleteLegalizationInfoFor(PlacementInfo::PlacementUnit *curPU)
    {
        if (PU2LegalSites.find(curPU) != PU2LegalSites.end())
            PU2LegalSites.erase(curPU);
        if (PULegalXY.first.find(curPU) != PULegalXY.first.end())
            PULegalXY.first.erase(curPU);
        if (PULegalXY.second.find(curPU) != PULegalXY.second.end())
            PULegalXY.second.erase(curPU);
    }
 
    inline void setCellBinInfo(int cellId, int sharedTypeId, int X, int Y, float occupation)
    {
        assert((unsigned int)cellId < cellId2CellBinInfo.size());
        cellId2CellBinInfo[cellId].sharedTypeId = sharedTypeId;
        cellId2CellBinInfo[cellId].X = X;
        cellId2CellBinInfo[cellId].Y = Y;
        cellId2CellBinInfo[cellId].occupation = occupation;
    }
 
    inline void transferCellBinInfo(int cellId, float fX, int fY)
    {
        assert((unsigned int)cellId < cellId2CellBinInfo.size());
        int binIdX, binIdY;
        getGridXY(fX, fY, binIdX, binIdY);
        assert(binIdY >= 0);
        assert((unsigned int)binIdY < SharedBELTypeBinGrid[cellId2CellBinInfo[cellId].sharedTypeId].size());
        assert(binIdX >= 0);
        assert((unsigned int)binIdX < SharedBELTypeBinGrid[cellId2CellBinInfo[cellId].sharedTypeId][binIdY].size());
        if (cellId2CellBinInfo[cellId].X == binIdX && cellId2CellBinInfo[cellId].Y == binIdY)
            return;
 
        assert(cellId2CellBinInfo[cellId].occupation >= 0);
        SharedBELTypeBinGrid[cellId2CellBinInfo[cellId].sharedTypeId][cellId2CellBinInfo[cellId].Y]
                            [cellId2CellBinInfo[cellId].X]
                                ->removeCell(designInfo->getCells()[cellId], cellId2CellBinInfo[cellId].occupation);
        SharedBELTypeBinGrid[cellId2CellBinInfo[cellId].sharedTypeId][binIdY][binIdX]->addCell(
            designInfo->getCells()[cellId], cellId2CellBinInfo[cellId].occupation);
        cellId2CellBinInfo[cellId].X = binIdX;
        cellId2CellBinInfo[cellId].Y = binIdY;
    }
 
    inline float getDisplacement(float fX, float fY, DeviceInfo::DeviceSite *curSite)
    {
        return std::fabs(fX - curSite->X()) + y2xRatio * std::fabs(fY - curSite->Y());
    }
 
    inline std::vector<DeviceInfo::DeviceSite *> *
    findNeiborSiteFromBinGrid(DesignInfo::DesignCell *curCell, float targetX, float targetY,
                              float displacementThreshold, int siteNumThreshold, bool checkClockRegion = false)
    {
        // please note that the input DesignCell is only used to find the corresponding binGrid for site search.
        std::vector<DeviceInfo::DeviceSite *> *res = new std::vector<DeviceInfo::DeviceSite *>(0);
 
        int binIdX, binIdY;
        getGridXY(targetX, targetY, binIdX, binIdY);
        auto curPU = getPlacementUnitByCellId(curCell->getCellId());
        int targetClockRegionX = -1;
        if (PU2ClockRegionColumn.find(curPU) != PU2ClockRegionColumn.end() && checkClockRegion)
        {
            targetClockRegionX = PU2ClockRegionColumn[curPU];
        }
 
        while (res->size() == 0)
        {
            auto sharedTypeIds = getPotentialBELTypeIDs(curCell->getCellType());
 
            for (auto sharedTypeId : sharedTypeIds)
            {
                assert((unsigned int)curCell->getCellId() < cellId2CellBinInfo.size());
                assert(binIdY >= 0);
                assert((unsigned int)binIdY < SharedBELTypeBinGrid[sharedTypeId].size());
                assert(binIdX >= 0);
                assert((unsigned int)binIdX < SharedBELTypeBinGrid[sharedTypeId][binIdY].size());
 
                std::vector<std::vector<PlacementBinInfo *>> &curBinGrid = SharedBELTypeBinGrid[sharedTypeId];
 
                std::queue<std::pair<int, int>> binXYqueue;
                std::set<std::pair<int, int>> reachedBinXYs;
                binXYqueue.emplace(binIdX, binIdY);
                reachedBinXYs.emplace(binIdX, binIdY);
 
                while (binXYqueue.size() > 0)
                {
                    std::pair<int, int> curXY = binXYqueue.front();
                    binXYqueue.pop();
                    int curbinIdX = curXY.first, curbinIdY = curXY.second;
 
                    PlacementBinInfo *curBin = curBinGrid[curbinIdY][curbinIdX];
                    float bin2TargetXYDistance = curBin->getManhattanDistanceTo(targetX, targetY);
                    if (bin2TargetXYDistance > displacementThreshold)
                        continue;
                    int findSiteCnt = 0;
                    for (auto curSite : curBin->getCorrespondingSites())
                    {
                        if (!curSite->isOccupied() && !curSite->isMapped())
                        {
                            if (getDisplacement(targetX, targetY, curSite) < displacementThreshold)
                            {
                                findSiteCnt++;
                                if (targetClockRegionX >= 0 && targetClockRegionX != curSite->getClockRegionX())
                                    continue;
                                res->push_back(curSite);
                            }
                        }
                    }
 
                    if (res->size() < (unsigned int)siteNumThreshold)
                    {
                        for (int nextY = curbinIdY - 1; nextY <= curbinIdY + 1; nextY++)
                        {
                            for (int nextX = curbinIdX - 1; nextX <= curbinIdX + 1; nextX++)
                            {
                                if (!(nextY >= 0))
                                    continue;
                                if (!((unsigned int)nextY < SharedBELTypeBinGrid[sharedTypeId].size()))
                                    continue;
                                if (!(nextX >= 0))
                                    continue;
                                if (!((unsigned int)nextX < SharedBELTypeBinGrid[sharedTypeId][binIdY].size()))
                                    continue;
                                PlacementBinInfo *nextBin = curBinGrid[nextY][nextX];
                                float nextBin2TargetXYDistance = nextBin->getManhattanDistanceTo(targetX, targetY);
                                if (nextBin2TargetXYDistance > displacementThreshold)
                                    continue;
                                std::pair<int, int> nextXY(nextX, nextY);
                                if (reachedBinXYs.find(nextXY) == reachedBinXYs.end())
                                {
                                    reachedBinXYs.insert(nextXY);
                                    binXYqueue.push(nextXY);
                                }
                            }
                        }
                    }
                }
            }
            displacementThreshold *= 1.5;
        }
 
        return res;
    }
 
    inline std::vector<CellBinInfo> &getCellId2CellBinInfo()
    {
        return cellId2CellBinInfo;
    }
 
    inline std::vector<DesignInfo::DesignCell *> &getCells()
    {
        return designInfo->getCells();
    }
 
    inline std::vector<std::vector<PlacementNet *>> &getPlacementUnitId2Nets()
    {
        return placementUnitId2Nets;
    }
 
    double updateB2BAndGetTotalHPWL()
    {
        double totalHPWL = 0.0;
        int numNet = placementNets.size();
 
#pragma omp parallel for
        for (int netId = 0; netId < numNet; netId++)
        {
            auto net = placementNets[netId];
            net->updateNetBounds(true, true);
        }
 
        //#pragma omp parallel for reduction(+ : totalHPWL)
        for (int netId = 0; netId < numNet; netId++)
        {
            auto net = placementNets[netId];
            totalHPWL += net->getHPWL(y2xRatio);
        }
        return totalHPWL;
    }
 
    double getTotalHPWL()
    {
        double totalHPWL = 0.0;
        int numNet = placementNets.size();
        //#pragma omp parallel for reduction(+ : totalHPWL)
        for (int netId = 0; netId < numNet; netId++)
        {
            auto net = placementNets[netId];
            totalHPWL += net->getHPWL(y2xRatio);
        }
        return totalHPWL;
    }
 
    inline void setProgress(float p)
    {
        placementProressRatio = p;
    }
 
    inline float getProgress()
    {
        return placementProressRatio;
    }
 
    void dumpCongestion(std::string dumpFileName);
 
    void dumpVivadoPlacementTclWithPULegalizationInfo(std::string dumpFile);
 
    void dumpPlacementUnitInformation(std::string dumpFile);
 
    void loadPlacementUnitInformation(std::string locationFile);
 
    inline void setPseudoNetWeight(float weight)
    {
        oriPseudoNetWeight = weight;
    }
 
    inline float getPseudoNetWeight()
    {
        assert(oriPseudoNetWeight > 0 && "should be set before get");
        return oriPseudoNetWeight;
    }
 
    inline int getMacroPseudoNetEnhanceCnt()
    {
        if (JSONCfg.find("DirectMacroLegalize") != JSONCfg.end())
        {
            if (JSONCfg["DirectMacroLegalize"] == "true")
            {
                return macroPseudoNetEnhanceCnt;
            }
        }
        assert(macroPseudoNetEnhanceCnt > 0 && "should be set before get");
        return macroPseudoNetEnhanceCnt;
    }
 
    inline float getMacroLegalizationWeight()
    {
        assert(macroLegalizationWeight > 0 && "should be set before get");
        return macroLegalizationWeight;
    }
 
    inline void setMacroLegalizationParameters(int cnt, float _macroLegalizationWeight)
    {
        macroPseudoNetEnhanceCnt = cnt;
        macroLegalizationWeight = _macroLegalizationWeight;
    }
 
    void resetLUTFFDeterminedOccupation()
    {
        designInfo->resetLUTFFDeterminedOccupation();
    }
 
    inline int getDeterminedOccupation(int cellId)
    {
        return designInfo->getDeterminedOccupation(cellId);
    }
 
    inline void setDeterminedOccupation(int cellId, int occupation)
    {
        designInfo->setDeterminedOccupation(cellId, occupation);
    }
 
    inline unsigned int getPairPinNum(DesignInfo::DesignCell *LUTA, DesignInfo::DesignCell *LUTB)
    {
        if (LUTA->getInputPins().size() == 6 || LUTB->getInputPins().size() == 6 || LUTA->isLUT6() || LUTB->isLUT6())
            return 12;
 
        int pinNumA = 0;
        int totalPin = 0;
        int netIds[5]; // be aware that a LUT might have pins connected to the same net and they should be treated as
                       // different inputs.
 
        for (auto tmpPin : LUTA->getInputPins())
        {
            if (!tmpPin->isUnconnected())
            {
                netIds[pinNumA] = tmpPin->getNet()->getElementIdInType();
                pinNumA++;
            }
        }
        totalPin = pinNumA;
        for (auto tmpPin : LUTB->getInputPins())
        {
            if (!tmpPin->isUnconnected())
            {
                bool matched = false;
                for (int i = 0; i < pinNumA; i++)
                {
                    if (netIds[i] >= 0 && netIds[i] == tmpPin->getNet()->getElementIdInType())
                    {
                        netIds[i] = -1;
                        matched = true;
                        break;
                    }
                }
                if (!matched)
                {
                    totalPin++;
                }
            }
        }
        return totalPin;
    }
 
    inline void calculateNetNumDistributionOfPUs()
    {
        int manyNetCnt = 0;
        for (auto tmpPU : placementUnits)
        {
            if (tmpPU->getNetsSetPtr()->size() >= 30)
            {
                manyNetCnt++;
            }
        }
        PUWithManyNetsRatio = (float)manyNetCnt / (float)placementUnits.size();
    }
 
    inline float getPUWithManyNetsRatio()
    {
        assert(PUWithManyNetsRatio >= 0);
        return PUWithManyNetsRatio;
    }
 
    inline void setMinHPWL(float val)
    {
        minHPWL = val;
    }
 
    inline float getMinHPWL()
    {
        return minHPWL;
    }
 
    bool checkClockUtilization(bool dump);
 
    void enhanceRiskyClockNet();
 
    void enhanceDDRNet();
 
    void enhanceHighFanoutNet();
 
    void dumpOverflowClockUtilization();
 
    inline bool checkClockColumnLegalization(PlacementInfo::PlacementUnit *curPU, DeviceInfo::DeviceSite *curSite)
    {
        auto clockColumn = curSite->getClockHalfColumn();
        auto curSetOfClocks = clockCol2ClockNets[clockColumn];
        auto curPUClocks = curPU->getClockNets();
        for (auto clockNet : curPUClocks)
            curSetOfClocks.insert(clockNet);
 
        if (curSetOfClocks.size() <= clockColumn->getClockNumLimit())
            return true;
        else
            return false;
    }
 
    inline int getClockColumnUtilizationIncrease(PlacementInfo::PlacementUnit *curPU, DeviceInfo::DeviceSite *curSite)
    {
        auto clockColumn = curSite->getClockHalfColumn();
        auto curSetOfClocks = clockCol2ClockNets[clockColumn];
        int oriClockNum = curSetOfClocks.size();
        auto curPUClocks = curPU->getClockNets();
        for (auto clockNet : curPUClocks)
            curSetOfClocks.insert(clockNet);
 
        return curSetOfClocks.size() - oriClockNum;
    }
 
    void printOutClockColumnLegalization(PlacementInfo::PlacementUnit *curPU, DeviceInfo::DeviceSite *curSite)
    {
        auto clockColumn = curSite->getClockHalfColumn();
        auto curSetOfClocks = clockCol2ClockNets[clockColumn];
        auto curPUClocks = curPU->getClockNets();
        for (auto clockNet : curPUClocks)
            curSetOfClocks.insert(clockNet);
        int i = 0;
        for (auto clockNet : curSetOfClocks)
        {
            std::cout << "clock#" << i << " name: [" << clockNet->getName() << "]\n";
            i++;
        }
    }
 
    void addPUIntoClockColumn(PlacementInfo::PlacementUnit *curPU, DeviceInfo::DeviceSite *curSite)
    {
        auto clockColumn = curSite->getClockHalfColumn();
        auto &curSetOfClocks = clockCol2ClockNets[clockColumn];
        auto &curPUClocks = curPU->getClockNets();
        for (auto clockNet : curPUClocks)
            curSetOfClocks.insert(clockNet);
        assert(curSetOfClocks.size() <= clockColumn->getClockNumLimit());
    }
 
    inline std::vector<std::vector<PlacementUnit *>> &getLongPaths()
    {
        return longPaths;
    }
 
    void optimizeLongPaths();
 
    void buildSimpleTimingGraph()
    {
        simplePlacementTimingInfo->buildSimpleTimingGraph();
        longPathThresholdLevel = simplePlacementTimingInfo->getLongPathThresholdLevel();
        mediumPathThresholdLevel = simplePlacementTimingInfo->getMediumPathThresholdLevel();
    }
 
    std::map<PlacementUnit *, std::pair<float, float>> &getPU2ClockRegionCenters()
    {
        return PU2ClockRegionCenters;
    }
 
    std::map<PlacementUnit *, int> &getPU2ClockRegionColumn()
    {
        return PU2ClockRegionColumn;
    }
 
    inline int getLongPathThresholdLevel()
    {
        return longPathThresholdLevel;
    }
 
    inline int getMediumPathThresholdLevel()
    {
        return mediumPathThresholdLevel;
    }
 
    inline std::map<DeviceInfo::ClockColumn *, std::set<DesignInfo::DesignNet *>> &getClockCol2ClockNets()
    {
        return clockCol2ClockNets;
    }
 
    inline std::vector<std::vector<PlacementBinInfo *>> &getGlobalBinGrid()
    {
        return globalBinGrid;
    }
 
    inline void setClusterNum(int _clusterNum)
    {
        clusterNum = _clusterNum;
    }
 
    inline int getClusterNum()
    {
        return clusterNum;
    }
 
    inline bool isDensePlacement()
    {
        return ((float)getClusterNum() / (float)getDeviceInfo()->getClockRegionNumX() /
                (float)getDeviceInfo()->getClockRegionNumY()) > 0.6;
    }
 
    inline bool isClockLegalizationRisky()
    {
        return clockLegalizationRisky;
    }
 
    inline int getHighFanOutThr()
    {
        return highFanOutThr;
    }
 
    inline int getNetDistributionByDensity(int density)
    {
        int ret = 0;
        for (int i = 0; i <= 7; i++)
        {
            if (netPinNumDistribution[i] >= density)
            {
                ret += netDistribution[i];
            }
        }
 
        return ret;
    }
 
    inline float getMacroRatio()
    {
        return macroRatio;
    }
 
    inline void setPaintDataBase(PaintDataBase *_paintData)
    {
        assert(_paintData);
        paintData = _paintData;
    }
 
    void transferPaintData();
 
  private:
    CompatiblePlacementTable *compatiblePlacementTable = nullptr;
    std::vector<PlacementUnit *> placementUnits;
    std::vector<PlacementUnpackedCell *> placementUnpackedCells;
    std::vector<PlacementMacro *> placementMacros;
    std::vector<PlacementUnit *> fixedPlacementUnits;
    std::set<DesignInfo::DesignCell *> cellInMacros;
    std::map<int, PlacementUnit *> cellId2PlacementUnit;
    std::vector<PlacementUnit *> cellId2PlacementUnitVec;
    std::vector<CellBinInfo> cellId2CellBinInfo;
    std::vector<Location> cellId2location;
    std::vector<Location> pinId2location;
    DesignInfo *designInfo;
    DeviceInfo *deviceInfo;
    PlacementTimingInfo *simplePlacementTimingInfo = nullptr;
    std::pair<std::map<PlacementInfo::PlacementUnit *, float>, std::map<PlacementInfo::PlacementUnit *, float>>
        PULegalXY;
    std::map<PlacementInfo::PlacementUnit *, std::vector<DeviceInfo::DeviceSite *>> PU2LegalSites;
 
    float globalMinX;
 
    float globalMinY;
 
    float globalMaxX;
 
    float globalMaxY;
 
    float startX;
 
    float startY;
 
    float endX;
 
    float endY;
 
    float eps = 1e-5;
    std::vector<std::vector<std::vector<PlacementBinInfo *>>> SharedBELTypeBinGrid;
 
    std::vector<std::vector<PlacementBinInfo *>> LUTFFBinGrid;
 
    std::vector<std::vector<PlacementBinInfo *>> globalBinGrid;
    std::vector<std::vector<PlacementSiteBinInfo *>> siteGridForMacros;
    float binWidth;
    float binHeight;
 
    std::vector<PlacementNet *> placementNets;
    std::vector<std::vector<PlacementNet *>> placementUnitId2Nets;
    std::vector<PlacementNet *> designNetId2PlacementNet;
 
    std::vector<PlacementNet *> clockNets;
    std::vector<std::vector<int>> clockRegionUtilization;
 
    std::set<PlacementUnit *> PUSetContainingFF;
    std::vector<PlacementUnit *> PUsContainingFF;
    std::vector<std::vector<PlacementUnit *>> longPaths;
 
    std::map<PlacementUnit *, std::pair<float, float>> PU2ClockRegionCenters;
    std::map<PlacementUnit *, int> PU2ClockRegionColumn;
    std::map<DeviceInfo::ClockColumn *, std::set<DesignInfo::DesignNet *>> clockCol2ClockNets;
    PaintDataBase *paintData = nullptr;
 
    std::vector<float> PaintXs;
    std::vector<float> PaintYs;
    std::vector<int> PaintTypes;
 
    typedef struct _ClockNetCoverage
    {
        PlacementNet *clockNet = nullptr;
 
        int leftRegionX;
 
        int rightRegionX;
 
        int topRegionY;
 
        int bottomRegionY;
    } ClockNetCoverage;
    std::vector<ClockNetCoverage> clockNetCoverages;
 
    float placementProressRatio = 0.01;
 
    std::map<std::string, std::string> &JSONCfg;
    std::string cellType2fixedAmoFileName;
    std::string cellType2sharedCellTypeFileName;
    std::string sharedCellType2BELtypeFileName;
    int netPinNumDistribution[8] = {8, 16, 24, 32, 64, 256, 512, 1000000};
    int netDistribution[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
    float y2xRatio = 1.0;
 
    int longPathThresholdLevel = 10;
 
    int mediumPathThresholdLevel = 5;
 
    int dumpPlacementUnitLocationCnt = 0;
 
    int clusterNum = 1;
    bool clockLegalizationRisky = false;
 
    float oriPseudoNetWeight = -1;
    int macroPseudoNetEnhanceCnt = -1;
    float macroLegalizationWeight = -1;
 
    float lastProgressWhenLUTFFUtilAdjust = -1.0;
    float PUWithManyNetsRatio = -1;
    float minHPWL = 1e8;
    bool LUTFFUtilizationAdjusted = false;
 
    int highFanOutThr = 10000000;
 
    float macroRatio = 0.0;
 
    bool guiEnable = false;
};
 
std::ostream &operator<<(std::ostream &os, PlacementInfo::PlacementMacro *curMacro);
std::ostream &operator<<(std::ostream &os, PlacementInfo::PlacementUnpackedCell *curUnpackedCell);
std::ostream &operator<<(std::ostream &os, PlacementInfo::PlacementUnit *curPU);
#endif