.. _program_listing_file_src_sta_HSTimingDelta.h:

Program Listing for File HSTimingDelta.h
========================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_sta_HSTimingDelta.h>` (``src/sta/HSTimingDelta.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 <unordered_map>
   #include <vector>
   
   #include "../partition/parallel_hashmap/phmap.h"
   #include "HSTimingEdge.h"
   #include "HSTimingLocalData.h"
   #include "HSTimingSlackRange.h"
   
   using phmap::flat_hash_map;
   using std::map;
   using std::pair;
   using std::set;
   using std::unordered_map;
   using std::vector;
   
   
   namespace HSFullTiming {
   
   class HSTimingDelta {
    public:
     HSTimingDelta(const HSPartitionFlow *parent,
                   const HSTimingLocalData *oneLocal);
   
     ~HSTimingDelta();
   
     int updateTimingEdge(const vector<int> &disableEdgeList,
                          const vector<int> &enableEdgeList,
                          const vector<int> &delayChangedEdgeList = {});
   
     int updateTimingEdge(vector<pair<int, int>> newParts);
   
     flat_hash_map<int, int> &getPartDelta()
     {
       return partDelta;
     }
   
     flat_hash_map<int, bool> &getEnableDelta()
     {
       return enableDelta;
     }
   
     flat_hash_map<uint64_t, slackData> &getSlackDelta()
     {
       return slackDelta;
     }
   
     map<int, int> &getHop2DataCnt()
     {
       return m_hop2DataCnt;
     }
   
     const flat_hash_map<int, map<int, int>> &getEdgeSlackBucketCntDelta() const
     {
       return m_edgeSlackBucketCntDelta;
     }
   
     const flat_hash_map<int, map<int, map<int, int>>> &
     getNetPair2EdgeMinSlackBucketCntByNetDelta() const
     {
       return m_netPair2EdgeMinSlackBucketCntByNetDelta;
     }
   
     const flat_hash_map<int, map<int, int>> &
     getNetPair2MinSlackBucketByNetDelta() const
     {
       return m_netPair2MinSlackBucketByNetDelta;
     }
   
     const map<int, int> &getNetCutSlack2Cnt() const
     {
       return m_netCutSlack2Cnt;
     }
   
     int getMaxHop() const;
   
     int getMaxHopDataCnt();
   
     double estimateTopkMinSlackSum(double topkMinSlackRatio = -1.0) const;
   
     int getWorstIndex(double topkMinSlackRatio = -1.0);
   
     int getCriticalCut(double topkMinSlackRatio = -1.0);
   
     void removeDataCnt(int edgeId, slackData *sData);
   
     void addDataCnt(int edgeId, slackData *sData);
   
     float getCutDelay(int edgeId);
   
     float getOldCutDelay(int edgeId);
   
     int getFPGADistance(int edgeId) const;
   
     int getOldFPGADistance(int edgeId) const;
   
     struct traceInfo {
       short hop     = 0;        
       float slack   = FLT_MAX;  
       int preEdgeId = -1;       
       int edgeId    = -1;       
     };
   
    private:
     int getPart(int nodeId) const;
   
     bool getEnable(int edgeId) const;
   
     uint64_t makeKey(int edgeId, int clkId)
     {
       return (uint64_t(uint32_t(edgeId)) << 32) | uint32_t(clkId);
     }
   
     slackData &getSlackData(int edgeId, int clkId);
   
     const slackData &getSlackData_ReadOnly(int edgeId, int clkId);
   
     pair<slackData *, bool> getSlackDataRW(int edgeId, int clkId);
   
     slackData *getSlackDataByPtr(int edgeId, slackData *src);
   
     const map<int, int> &getEdgeSlackBucketCnt_ReadOnly(int edgeId) const;
   
     map<int, int> &getEdgeSlackBucketCntRW(int edgeId);
   
     const map<int, map<int, int>> &
     getNetPair2EdgeMinSlackBucketCntByNet_ReadOnly(int netId) const;
   
     map<int, map<int, int>> &getNetPair2EdgeMinSlackBucketCntByNetRW(int netId);
   
     const map<int, int> &getNetPair2MinSlackBucketByNet_ReadOnly(int netId) const;
   
     map<int, int> &getNetPair2MinSlackBucketByNetRW(int netId);
   
     int updateTimingEdge(map<int, vector<map<int, traceInfo>>> &clk2TraceList,
                          bool bPostTrace);
   
     bool setWorseSlack(int clkId, traceInfo &trace, bool bPostValue);
   
     int getSlackIndex(float slack)
     {
       return HSFullTiming::slackToBucketIndex(slack);
     }
   
     int getFPGADistanceByPart(int partFrom, int partTo) const;
   
     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);
   
     void updateNetCutSlackStatsForEdges(const set<int> &edgeIds);
   
     const HSPartitionFlow *m_parent =
         nullptr;  
     const HSTimingLocalData *m_localData =
         nullptr;  
     const vector<HSOuterEdge *> &m_outerEdgeAll;  
     const vector<HSTimingEdge *> &m_timingEdgeAll;  
     const vector<int> &m_partInfo;  
     const vector<vector<float>>
         &m_cutDelays;  
     const vector<vector<int>>
         &m_fpgaDistances;  
     const vector<map<int, int>>
         &m_edgeSlackBucketCntBase;  
     const vector<map<int, map<int, int>>>
         &m_netPair2EdgeMinSlackBucketCntByNetBase;  
     const vector<map<int, int>>
         &m_netPair2MinSlackBucketByNetBase;  
     flat_hash_map<int, int> partDelta;  
     flat_hash_map<int, bool>
         enableDelta;  
     flat_hash_map<uint64_t, slackData>
         slackDelta;  
     map<int, int>
         m_hop2DataCnt;  
     flat_hash_map<int, map<int, int>>
         m_edgeSlackBucketCntDelta;  
     flat_hash_map<int, map<int, map<int, int>>>
         m_netPair2EdgeMinSlackBucketCntByNetDelta;  
     flat_hash_map<int, map<int, int>>
         m_netPair2MinSlackBucketByNetDelta;  
     map<int, int>
         m_netCutSlack2Cnt;  
     static constexpr int kInvalidTimingCutPairKey =
         -1;  
     static constexpr int kTimingCutPairKeyBase =
         1024;  
     static constexpr int kInvalidSlackBucket =
         std::numeric_limits<int>::max();  
   };
   
   }  // namespace HSFullTiming