GlobalPlacer.h

Go to the documentation of this file.

 
#ifndef _GLOBALPLACER
#define _GLOBALPLACER
 
#include "CLBLegalizer.h"
#include "ClusterPlacer.h"
#include "DesignInfo.h"
#include "DeviceInfo.h"
#include "Eigen/SparseCore"
#include "GeneralSpreader.h"
#include "MacroLegalizer.h"
#include "PlacementInfo.h"
#include "PlacementTimingOptimizer.h"
#include "WirelengthOptimizer.h"
#include "dumpZip.h"
//#include "osqp++/osqp++.h"
#include <assert.h>
#include <fstream>
#include <iostream>
#include <map>
#include <mutex>
#include <semaphore.h>
#include <set>
#include <sstream>
#include <string>
#include <thread>
#include <vector>
 
class GlobalPlacer
{
  public:
    GlobalPlacer(PlacementInfo *placementInfo, std::map<std::string, std::string> &JSONCfg,
                 bool resetLegalizationInfo = true);
    ~GlobalPlacer()
    {
        if (clusterPlacer)
            delete clusterPlacer;
        if (WLOptimizer)
            delete WLOptimizer;
        if (generalSpreader)
            delete generalSpreader;
        if (BRAMDSPLegalizer)
            delete BRAMDSPLegalizer;
        if (CARRYMacroLegalizer)
            delete CARRYMacroLegalizer;
        if (mCLBLegalizer)
            delete mCLBLegalizer;
        if (lCLBLegalizer)
            delete lCLBLegalizer;
    }
 
    void clusterPlacement();
 
    void GlobalPlacement_CLBElements(int iterNum, bool continuePreviousIteration = false, int lowerBoundIterNum = 6,
                                     bool enableMacroPseudoNet2Site = false, bool stopStrictly = false,
                                     unsigned int spreadRegionBinNumLimit = 10000000,
                                     PlacementTimingOptimizer *timingOptimizer = nullptr);
 
    void GlobalPlacement_fixedCLB(int iterNum, float pseudoNetWeight);
 
    inline void setPseudoNetWeight(float weight)
    {
        oriPseudoNetWeight = weight;
    }
 
    inline float getPseudoNetWeight()
    {
        return oriPseudoNetWeight;
    }
 
    inline int getMacroPseudoNetEnhanceCnt()
    {
        return WLOptimizer->getMacroPseudoNetEnhanceCnt();
    }
 
    inline float getMacroLegalizationWeight()
    {
        return WLOptimizer->getMacroLegalizationWeight();
    }
 
    inline void setMacroLegalizationParameters(int cnt, float macroLegalizationWeight)
    {
        WLOptimizer->setMacroLegalizationParameters(cnt, macroLegalizationWeight);
    }
 
    inline void setMacroLegalizationFixed()
    {
        macroLegalizationFixed = true;
    }
 
    inline void setNeighborDisplacementUpperbound(float _threshold)
    {
        neighborDisplacementUpperbound = _threshold;
    }
 
    void spreading(int currentIteration, int spreadRegionSizeLimit = 100000000, float displacementLimit = -10);
 
    inline WirelengthOptimizer *getWirelengthOptimizer()
    {
        assert(WLOptimizer);
        return WLOptimizer;
    }
 
    int timingDrivenDetailedPlacement_shortestPath_intermediate(PlacementTimingOptimizer *timingOptimizer);
 
  private:
    PlacementInfo *placementInfo;
 
    // settings
    std::map<std::string, std::string> &JSONCfg;
    bool verbose = false;
    bool dumpOptTrace = false;
    float y2xRatio = 1.0;
 
    bool pseudoNetWeightConsiderNetNum = true;
 
    bool disableSpreadingForgetRatio = false;
 
    ClusterPlacer *clusterPlacer = nullptr;
 
    WirelengthOptimizer *WLOptimizer = nullptr;
 
    GeneralSpreader *generalSpreader = nullptr;
 
    MacroLegalizer *BRAMDSPLegalizer = nullptr;
 
    MacroLegalizer *CARRYMacroLegalizer = nullptr;
 
    CLBLegalizer *mCLBLegalizer = nullptr;
 
    CLBLegalizer *lCLBLegalizer = nullptr;
 
    void updatePseudoNetWeight(float &pseudoNetWeight, int curIter);
 
    void macroLegalize(int curIteration, bool timingDriven = false,
                       PlacementTimingOptimizer *timingOptimizer = nullptr);
 
    void printPlacedUnits(std::ostream &os);
    void dumpLUTCoordinate();
    void dumpDSPCoordinate(bool enforced = false);
    void dumpBRAMCoordinate(bool enforced = false);
    void dumpFFCoordinate();
    void dumpLUTFFCoordinate(bool enforced = false);
    void dumpAllCellsCoordinate();
    void dumpCARRYCoordinate();
    void dumpCoord();
    inline float random_float(float min, float max)
    {
        return ((float)random() / RAND_MAX) * (max - min) + min;
    }
 
    /*
     * some counters indicating the numbers of the dumped log and naming them accordingly
     *
     */
 
    int LUTCoordinateDumpCnt = 0;
    int DSPCoordinateDumpCnt = 0;
    int BRAMCoordinateDumpCnt = 0;
    int FFCoordinateDumpCnt = 0;
    int LUTFFCoordinateDumpCnt = 0;
    int CARRYCoordinateDumpCnt = 0;
    int allCoordinateDumpCnt = 0;
 
    float spreadingForgetRatio = 0.2;
 
    float progressRatio = 0.0;
 
    float averageMacroLegalDisplacement = 100000;
 
    float averageCarryLegalDisplacement = 100000;
 
    float averageMCLBLegalDisplacement = 100000;
 
    std::deque<float> historyHPWLs;
    float minHPWL;
 
    float upperBoundHPWL;
 
    float lowerBoundHPWL;
 
    bool updateMinHPWLAfterLegalization = false;
 
    bool HPWLChangeLittle = false;
 
    bool macrosBindedToSites = false;
 
    bool macroCloseToSite = false;
 
    bool macroLocked = false;
 
    bool macroLegalizationFixed = false;
 
    bool directMacroLegalize = false;
 
    bool dumpClockUtilization = false;
 
    bool DSPCritical = false;
 
    int macroLockedIterCnt = 0;
    std::deque<float> historyAverageDisplacement;
 
    float oriPseudoNetWeight = -1.0;
 
    float pseudoNetWeight = 1.0;
 
    float neighborDisplacementUpperbound = -1.0;
 
    bool hasUserDefinedClusterInfo = false;
    bool enableClockRegionAware = false;
    bool timingOptEnabled = false;
    bool printHPWL = false;
};
 
#endif