Program Listing for File HSTimingDelta.h

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

#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