.. _program_listing_file_src_sta_HSTimingLocalData.h:

Program Listing for File HSTimingLocalData.h
============================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_sta_HSTimingLocalData.h>` (``src/sta/HSTimingLocalData.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include <float.h>
   
   #include <limits>
   #include <map>
   #include <set>
   #include <string>
   #include <vector>
   
   #include "HSIOTdmDelay.h"
   #include "HSTimingEdge.h"
   #include "HSTimingSlackRange.h"
   #include "HSTimingUndo.h"
   
   using std::map;
   using std::pair;
   using std::vector;
   
   class graph;
   
   
   namespace HSFullTiming {
   class HSPartitionFlow;
   class HSOuterEdge;
   class HSTimingDelta;
   
   class HSTimingLocalData {
    public:
     HSTimingLocalData(const HSPartitionFlow *parent);
   
     ~HSTimingLocalData();
   
     HSTimingLocalData *clone() const;
   
     void buildTimingEdge();
   
     void setHasCutDelay(bool hasCutDelay)
     {
       m_hasCutDelay = hasCutDelay;
     }
   
     int updatePartInfo();
   
     int updatePartInfo(const vector<int> &partInfo);
   
     const vector<int> &getPartInfo() const;
   
     int updateTimingEdge(bool allUpdate);
   
     int updateTimingEdge(
         const vector<int> &disableEdgeList, const vector<int> &enableEdgeList,
         const vector<int> &delayChangedEdgeList = {});
   
     int updateTimingEdge(vector<pair<int, int>> newParts);
   
     const vector<HSTimingEdge *> &getTimingEdge() const;
   
     const vector<HSOuterEdge *> &getOuterEdge() const;
   
     const vector<vector<float>> &getCutDelays() const
     {
       return m_cutDelays;
     }
   
     const vector<vector<int>> &getFPGADistances() const
     {
       return m_fpgaDistances;
     }
   
     void setEnableRollback(bool enableRollback);
   
     void rollbackUndo();
   
     void compare(HSTimingLocalData *oneLocal, bool verifyRollback = false);
   
     void verifyHop2DataCnt();
     // daiyt: 获取maxHop
     int getMaxHop() const;
   
     int getMaxHopDataCnt();
     // daiyt: 基于当前“按 net+FPGA pair 去重后的 slack bucket 统计”
     // 估计前K个最差slack之和。
     // K 由当前总割边数自适应决定，并允许使用小数以减小突变。
     // 若未传入比例，则默认使用当前实例的 m_topkMinSlackRatio。
     double estimateTopkMinSlackSum(double topkMinSlackRatio = -1.0) const;
   
     void setTopkMinSlackRatio(double topkMinSlackRatio)
     {
       m_topkMinSlackRatio = (topkMinSlackRatio > 0.0) ? topkMinSlackRatio : 0.0;
     }
   
     double getTopkMinSlackRatio() const
     {
       return m_topkMinSlackRatio;
     }
   
     map<int, int> getHop2DataCnt() const
     {
       return m_hop2DataCnt;
     }
     // daiyt: 获取前K个最差slack
     vector<float> getTopkMinSlack(int k);
   
     float getMinSlack();
     
     float getPercentileSlack(float &ratio);
   
     float getAverageSlack();
   
     void printTopkPaths(int k);
   
     void dumpTopkSlackToFile(int k, const std::string &filepath);
   
     void dumpNetCutSlackToFile(const std::string &filepath) const;
   
     void applyDelta(HSTimingDelta *delta);
   
     void setCutDelays(const vector<vector<float>> cutDelays)
     {
       m_cutDelays = cutDelays;
     }
   
     void setFPGADistances(const vector<vector<int>> fpgaDistances)
     {
       m_fpgaDistances = fpgaDistances;
     }
   
     const HSPartitionFlow *getParent() const
     {
       return m_parent;
     }
   
     float getCutDelay(int edgeId) const;
   
     int getFPGADistance(int edgeId) const;
   
     void addSlackUndo(slackData *sData, bool bPostValue);
   
     void removeDataCnt(int edgeId, slackData *sData);
   
     void addDataCnt(int edgeId, slackData *sData);
   
     void setCutWeights(vector<vector<int>> cutWeights)
     {
       m_cutWeights = cutWeights;
     }
   
     double computeCutDelta(const vector<vector<int>> &cutWeights);
   
     int getId();
   
     void setTdmEstimate(const HSIOTdmDelay &tdmEstimate)
     {
       m_tdmEstimate = tdmEstimate;
     }
   
     void updateCutDelays(const graph &g, const vector<int> &parts,
                          bool useTdmDelay, bool withNet = false);
   
     bool isEmptyIO() const
     {
       return m_tdmEstimate.isEmptyIO();
     }
   
     int getWorstIndex(double topkMinSlackRatio = -1.0);
   
     int getCriticalCut(double topkMinSlackRatio = -1.0);
   
     const vector<map<int, int>> &getNetPair2MinSlackBucketByNet() const
     {
       return m_netPair2MinSlackBucketByNet;
     }
   
     const vector<map<int, int>> &getEdgeSlackBucketCnt() const
     {
       return m_edgeSlackBucketCnt;
     }
   
     const vector<map<int, map<int, int>>> &getNetPair2EdgeMinSlackBucketCntByNet()
         const
     {
       return m_netPair2EdgeMinSlackBucketCntByNet;
     }
   
     const map<int, int> &getNetCutSlack2Cnt() const
     {
       return m_netCutSlack2Cnt;
     }
   
     float getOldCutDelay(int edgeId);
   
     int getOldFPGADistance(int edgeId) const;
   
     struct traceInfo {
       short hop = 0;          
       float slack = FLT_MAX;  
       int preEdgeId = -1;     
       int edgeId = -1;        
     };
   
    private:
     void clearTimingEdge();
   
     void initTimingEdge();
   
     int updateTimingEdge(map<int, vector<map<int, traceInfo>>> &clk2TraceList,
                          bool bPostTrace, bool bRetrace);
   
     void rebuildNetCutSlackStats();
   
     void updateNetCutSlackStatsForEdges(const set<int> &edgeIds);
   
     int getTimingCutPairKey(int edgeId, bool useOldPart) const;
   
     int getNetCutMinSlackBucket(int netId, int pairKey) const;
   
     int getEdgeMinSlackBucket(int edgeId) const;
   
     int getMinSlackBucket(const map<int, int> &bucket2Cnt) const;
   
     void updateNetCutSlackOnEdgeMinChange(int netId, int pairKey,
                                           int oldEdgeMinSlackBucket,
                                           int newEdgeMinSlackBucket);
   
     int getSlackIndex(float slack) const
     {
       return HSFullTiming::slackToBucketIndex(slack);
     }
   
     int getFPGADistanceByPart(int partFrom, int partTo) const;
   
     const HSPartitionFlow *m_parent =
         nullptr;  
     const vector<HSOuterEdge *> &m_outerEdgeAll;  
     vector<HSTimingEdge *>
         m_timingEdgeAll;  
     std::vector<int> m_partInfo;  
     vector<vector<float>> m_cutDelays;  
     vector<vector<int>>
         m_fpgaDistances;  
     bool m_hasCutDelay =
         true;  
     vector<vector<int>> m_cutWeights;  
     HSIOTdmDelay m_tdmEstimate;  
     map<int, int> m_hop2DataCnt;  
     map<int, int>
         m_netCutSlack2Cnt;  
     vector<map<int, int>>
         m_edgeSlackBucketCnt;  
     vector<map<int, map<int, int>>>
         m_netPair2EdgeMinSlackBucketCntByNet;  
     vector<map<int, int>>
         m_netPair2MinSlackBucketByNet;  
   
     bool m_enableRollback = false;  
     bool m_incUpdate      = false;  
     map<int, int> m_partUndo;  
     vector<EnableUndo> m_enableUndo;  
     vector<SlackUndo> m_slackUndo;  
     map<int, int> m_hop2DataCntUndo;  
     map<int, map<int, int>>
         m_edgeSlackBucketCntUndo;  
     map<int, map<int, map<int, int>>>
         m_netPair2EdgeMinSlackBucketCntUndo;  
     map<int, map<int, int>>
         m_netPair2MinSlackBucketUndo;  
     map<int, int>
         m_netCutSlack2CntUndo;  
   
     static constexpr int kInvalidTimingCutPairKey =
         -1;  
     static constexpr int kTimingCutPairKeyBase =
         1024;  
     static constexpr int kInvalidSlackBucket =
         std::numeric_limits<int>::max();  
     static constexpr double kDefaultTopkMinSlackRatio =
         0.12;  
     double m_topkMinSlackRatio =
         kDefaultTopkMinSlackRatio;  
   };
   
   }  // namespace HSFullTiming