Program Listing for File HSTimingLocalData.h

↰ Return to documentation for file (src/sta/HSTimingLocalData.h)

#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