WirelengthOptimizer.h

Go to the documentation of this file.

 
#ifndef _WIRELENGTHOPTIMIZER
#define _WIRELENGTHOPTIMIZER
 
#include "DesignInfo.h"
#include "DeviceInfo.h"
#include "Eigen/Eigen"
#include "Eigen/SparseCore"
#include "PlacementInfo.h"
#include "PlacementTimingOptimizer.h"
#include "QPSolverWrapper.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 WirelengthOptimizer
{
  public:
    WirelengthOptimizer(PlacementInfo *placementInfo, std::map<std::string, std::string> &JSONCfg, bool verbose = true);
    ~WirelengthOptimizer()
    {
        if (xSolver)
            delete xSolver;
        if (ySolver)
            delete ySolver;
        for (auto list : PNetId2SlackEnhanceTuples)
        {
            if (list)
                delete list;
        }
    }
 
    void GlobalPlacementQPSolve(float pesudoNetWeight, bool firstIteration = true,
                                bool forwardSolutionToNextIteration = false, bool enableMacroPseudoNet2Site = false,
                                bool considerNetNum = true, bool enableUserDefinedClusterOpt = false,
                                float displacementLimit = -10, PlacementTimingOptimizer *timingOptimizer = nullptr);
 
    void updateB2BNetWeight(float pesudoNetWeight, bool enableMacroPseudoNet2Site = false, bool considerNetNum = true,
                            bool enableUserDefinedClusterOpt = false,
                            PlacementTimingOptimizer *timingOptimizer = nullptr);
 
    static void updateB2BNetWeightWorker(PlacementInfo *placementInfo,
                                         std::vector<Eigen::Triplet<float>> &objectiveMatrixTripletList,
                                         std::vector<float> &objectiveMatrixDiag, Eigen::VectorXd &objectiveVector,
                                         float generalNetWeight, float y2xRatio, bool updateX, bool updateY);
 
    void reloadPlacementInfo();
 
    inline void setMacroLegalizationParameters(int cnt, float macroLegalizationWeight)
    {
        macroPseudoNetCnt = cnt;
        oriMacroLegalizationWeight = macroLegalizationWeight;
    }
 
    inline int getMacroPseudoNetEnhanceCnt()
    {
        return macroPseudoNetCnt;
    }
 
    inline float getMacroLegalizationWeight()
    {
        return oriMacroLegalizationWeight;
    }
 
    inline void clearNetPinEnhanceRate()
    {
        netPinEnhanceRate.clear();
    }
 
    inline void setGeneralTimingNetWeight(float _generalTimingNetWeight)
    {
        generalTimingNetWeight = _generalTimingNetWeight;
    }
 
    inline void setSlackPowerFactor(double _slackPowerFactor)
    {
        slackPowerFactor = _slackPowerFactor;
    }
 
  private:
    static void QPSolve(QPSolverWrapper *&curSolver);
 
    void solverLoadData();
 
    void solverLoadFixedData();
 
    void solverWriteBackData(float displacementLimit);
 
    void addPseudoNetForMacros(float pesudoNetWeight, bool considerNetNum);
 
    void addPseudoNet2LoctionForAllPUs(float pesudoNetWeight, bool considerNetNum);
 
    void updatePseudoNetForUserDefinedClusters(float pesudoNetWeight);
 
    typedef struct _slackEnhanceTuple
    {
        float weight;
        int PUAId, PUBId, PinAId, PinBId;
        float YEnhance;
 
        _slackEnhanceTuple(float weight, int PUAId, int PUBId, int PinAId, int PinBId, float YEnhance = 1.0)
            : weight(weight), PUAId(PUAId), PUBId(PUBId), PinAId(PinAId), PinBId(PinBId), YEnhance(YEnhance)
        {
        }
        _slackEnhanceTuple()
        {
        }
    } slackEnhanceTuple;
 
    std::vector<std::vector<slackEnhanceTuple> *> PNetId2SlackEnhanceTuples;
 
    void addPseudoNet_SlackBased(float timingWeight, double slackPowFactor, PlacementTimingOptimizer *timingOptimizer,
                                 bool calculate = false);
 
    void LUTLUTPairing_TimingDriven(float timingWeight, float disThreshold, PlacementTimingOptimizer *timingOptimizer);
 
    void updatePseudoNetForClockRegion(float pesudoNetWeight);
 
    inline double manhattanDis(double x0, double y0, double x1, double y1)
    {
        return std::abs(x0 - x1) + y2xRatio * std::abs(y0 - y1);
    }
    inline float getCellDistance(PlacementInfo::Location &A, PlacementInfo::Location &B)
    {
        return fabs(A.X - B.X) + y2xRatio * fabs(A.Y - B.Y);
    }
 
    typedef struct _PUWithScore
    {
        PlacementInfo::PlacementUnit *PU;
        float score;
 
        _PUWithScore(PlacementInfo::PlacementUnit *PU, float score) : PU(PU), score(score)
        {
        }
    } PUWithScore;
    typedef struct _CellWithScore
    {
        DesignInfo::DesignCell *cell;
        float score;
 
        _CellWithScore(DesignInfo::DesignCell *cell, float score) : cell(cell), score(score)
        {
        }
    } CellWithScore;
 
    PlacementInfo *placementInfo;
 
    QPSolverWrapper *xSolver = nullptr;
    QPSolverWrapper *ySolver = nullptr;
    std::map<std::string, std::string> &JSONCfg;
    bool verbose;
 
    float generalNetWeight = 1.0;
    float generalTimingNetWeight = 1.0;
    double slackPowerFactor = 1.1;
 
    float y2xRatio = 1.0;
 
    bool useUnconstrainedCG = true;
 
    bool MKLorNot = false;
 
    bool directMacroLegalize = false;
 
    bool DSPCritical = false;
 
    float pin2pinEnhance = 5.0;
 
    float userDefinedClusterFadeOutFactor = 1.0;
 
    float oriMacroLegalizationWeight = 1.0;
 
    int macroPseudoNetCnt = 0;
 
    std::map<DesignInfo::DesignNet *, std::vector<float>> netPinEnhanceRate;
 
    float slackThr = 0;
 
    // For debug usage
    std::string targetCellName = "design_1_i/DigitRec_0/inst/ap_phi_reg_pp2_iter31_knn_set_392_1_reg_27413_reg[20]";
    int targetCellId = -1;
};
 
#endif