Program Listing for File evaluator.h

↰ Return to documentation for file (src/partition/evaluator.h)

#ifndef EVALUATOR_H
#define EVALUATOR_H

#include "../sta/sta.h"
#include "tools.h"

using namespace std;
using phmap::flat_hash_map;


struct TimingPathCompare {
  bool operator()(const TimingPath &a, const TimingPath &b)
  {
    return floatNumLess(a.slack_new, b.slack_new);
  }
};

struct PathStats {
  int tot_num_path =
      0;
  int worst_cut_path = 0;
  int tot_cut_on_all_path =
      0;
  float avg_cut_path = 0;

  // the following slacks are relative values before guardband
  // minimum slack of all the paths before partitioning
  float old_worst_slack =
      1;
  // minimum slack of all the paths after partitioning
  float new_worst_slack =
      1;

  // Cut on the timing path with the minimum slack before partitioning
  int cut_on_worstSlackOfOld =
      0;
  // Cut on the timing path with the minimum slack after partitioning
  int cut_on_worstSlackOfNew = 0;
  int new_index = 0;
  int old_index = 0;

  // TritonPart的评价指标(该项目可能只作参考统计使用)
  int tot_num_critical_path = 0;
  int tot_num_noncritical_path =
      0;
  int worst_cut_critical_path =
      0;
  // average number of cuts on each critical path
  float avg_cut_critical_path = 0;
  // total number of noncritical paths become critical
  int number_non2critical_path =
      0;
  // worst number of cuts on noncritical paths that become critical
  int worst_cut_non2critical_path =
      0;
  // average number of cuts on noncritical paths that become critical
  float avg_cut_non2critical_path =
      0.0f;
  float fpga_delay =
      0.0f;
  float die_delay = 0.0f;
  int worst_die_hop =
      0;
  // Hop on the timing path with the minimum slack before partitioning
  int die_hop_on_worstSlackOfOld =
      0;
  // Hop on the timing path with the minimum slack after partitioning
  int die_hop_on_worstSlackOfNew =
      0;
  vector<int> block_path;
  vector<double> tdm_path;
};

class timingEvaluator {
 private:
  float net_timing_factor_coarse;
  float net_timing_factor_refine;
  float path_timing_factor;
  float
      path_snaking_factor;
  float timing_exp_factor;
  bool guardband_flag;
  int has_timing_propogate;
  int propogate_effort_value;
  int path_slack_update_mode;
  int enable_partition_HSFulltiming;
  // int isUpdateGraph;
  int skip_path_timing;
  flat_hash_map<pair<int, int>, pinSlack>
      pin_minslack;
  flat_hash_map<pair<int, int>, vector<int>>
      pin_paths;
  vector<TimingPath>
      original_timing_paths;
  shared_ptr<curPartStatus>
      mulClock_status;
  graph
      originHgraph;
  shared_ptr<mulClockAttr>
      clockAttr;

 public:
  timingEvaluator(float net_timing_factor_coarse,
                  float net_timing_factor_refine, float path_timing_factor,
                  float path_snaking_factor, float timing_exp_factor,
                  bool guardband_flag, int has_timing_propogate,
                  int propogate_effort_value,
                  flat_hash_map<pair<int, int>, pinSlack> pin_minslack,
                  flat_hash_map<pair<int, int>, vector<int>> pin_paths,
                  vector<TimingPath> original_timing_paths,
                  int path_slack_update_mode,
                  shared_ptr<curPartStatus> mulClock_status, graph originHgraph,
                  shared_ptr<mulClockAttr> clockAttr,
                  int enable_partition_HSFulltiming, int skip_path_timing);

  timingEvaluator();

  timingEvaluator(const timingEvaluator &) = delete;
  timingEvaluator(timingEvaluator &)       = delete;
  virtual ~timingEvaluator()               = default;

  float getNetTimingFactorCoarse() const
  {
    return net_timing_factor_coarse;
  }
  float getNetTimingFactorRefine() const
  {
    return net_timing_factor_refine;
  }
  float getPathtimingfactor() const
  {
    return path_timing_factor;
  }
  float getPathSnakingFactor() const
  {
    return path_snaking_factor;
  }
  float getTimingExpFactor() const
  {
    return timing_exp_factor;
  }
  bool getGuardbandFlag() const
  {
    return guardband_flag;
  }
  int getTimingPropogateFlag() const
  {
    return has_timing_propogate;
  }
  int getPropogaEffortValue() const
  {
    return propogate_effort_value;
  }
  int getPathSlackUpdateMode() const
  {
    return path_slack_update_mode;
  }
  int getEnablePartitionHSFulltiming() const
  {
    return enable_partition_HSFulltiming;
  }
  int getSkipPathTiming() const
  {
    return skip_path_timing;
  }

  shared_ptr<curPartStatus> getMulClockStatus() const
  {
    return mulClock_status;
  }
  flat_hash_map<pair<int, int>, pinSlack> getPinSlacks() const
  {
    return pin_minslack;
  }
  flat_hash_map<pair<int, int>, vector<int>> getInsPinPaths() const
  {
    return pin_paths;
  }
  vector<TimingPath> getTimingPaths() const
  {
    return original_timing_paths;
  }
  graph getOriginHgraph() const
  {
    return originHgraph;
  }
  shared_ptr<mulClockAttr> getClockAttr() const
  {
    return clockAttr;
  }

  timing init(timing timingInfo) const;

  // --------------------------------------------------------------------------------
  // // 时序评价与统计汇报使用的静态工具接口：
  // --------------------------------------------------------------------------------
  // //

  static int getCutOnPath(const vector<int> &path, const vector<int> &parts);

  static PathStats getTimingCutsOld(const graph &hgraph,
                                    const vector<int> &parts,
                                    const float &extra_delay_cut);

  static void PrintPathStatsOld(const PathStats &path_stats);

  static PathStats getTimingCuts2(
      graph &hgraph, const vector<int> &parts, const vector<vector<int>> &dist,
      const int &guardband_flag, const float &extra_delay_cut,
      float &maximum_clock_period, shared_ptr<timingEvaluator> &evaluator,
      const int &fpga_num,
      const flat_hash_map<int, float> &original_pin_minslack,
      const flat_hash_map<pair<int, int>, vector<int>> &pin_paths,
      const vector<TimingPath> &original_timing_paths,
      const int &has_timing_base);

  static void PrintSlackStats(const PathStats &path_stats, const bool &has_die,
                              const bool &consider_tdm,
                              const shared_ptr<mulClockAttr> &mul_clock_attr,
                              const vector<TimingPath> &timing_paths);

  static void PrintPathStats(PathStats &path_stats,
                             vector<TimingPath> &timing_paths,
                             const bool &has_die, const bool &consider_tdm,
                             const shared_ptr<mulClockAttr> &mul_clock_attr);

  static ofstream
      fout;

  static float getWorstSlackAfterCutsForOldSlack(
      graph &hgraph, const vector<int> &parts, const vector<vector<int>> &dist,
      const int &guardband_flag,
      const shared_ptr<curPartStatus> &mulClock_status);

  static float getWorstSlackAfterCutsForOldSlackConsideringTDM(
      graph &hgraph, const vector<int> &parts, const fpga &fpgas,
      const int &guardband_flag,
      const shared_ptr<curPartStatus> &mulClock_status);

  static float getWorstSlackAfterCuts(graph &hgraph, const vector<int> &parts,
                                      const float &extra_delay_cut,
                                      const int &guardband_flag,
                                      const float &clock_period);

  // --------------------------------------------------------------------------------
  // //
  // 细化(Refinement)阶段提供的高频热区微操计算引擎。负责单点腾挪带来的分数加减快速反查：
  // --------------------------------------------------------------------------------
  // //

  static float calCutNetgCost(const graph &g, const vector<int> &parts,
                              int fpga_num);

  static float calCutPathCost(int path_id, const timing &timingInfo,
                              const vector<int> &parts,
                              const vector<vector<int>> &dist,
                              const float &path_timing_factor,
                              const float &path_snaking_factor, const int &v,
                              const int &to);

  static vector<float> getCutPathsCost(const timing &timingInfo,
                                       const vector<int> &parts,
                                       const vector<vector<int>> &dist,
                                       const float &path_timing_factor,
                                       const float &path_snaking_factor);

  static vector<int> getCutHyperedges(const graph &g, const vector<int> &parts,
                                      const vector<pair<int, int>> &die_parts);

  static timing updateTiming(
      const int &has_timing_propogate, shared_ptr<timingEvaluator> evaluator,
      const vector<int> &parts, const fpga &fpgas, const bool &has_timing_tdm,
      const int &path_slack_update_mode, const graph &finest,
      const bool &isUpdateCost, HSFullTiming::HSPartitionFlow &pFlow,
      const shared_ptr<mulClockAttr> &clockAttr, const int &enable_HSFulltiming,
      timing &updatedTimingInfo, float &worst_slack);

  static void preprocessPpath(
      const vector<TimingPath> &original_timing_paths,
      vector<flat_hash_map<pair<int, int>, int>> &ppathValue_to_index,
      const int &psize);

  static void getCutEdgeIds(
      const vector<int> &cut_hyperedges, const graph &g,
      const vector<int> &parts,
      const flat_hash_map<int, set<pair<int, int>>> &net_insPin_set,
      const flat_hash_map<pair<int, int>, int> &pin2Edge, vector<int> &edgeIds,
      const int &l);

  static int convertPathToSimpleTiming(
      HSFullTiming::HSPartitionFlow &pFlow,
      vector<HSFullTiming::HSStaBase::timingpath> &path,
      vector<SimpleTiming> &simpleTimingsCut);

  static void getCutEdgePath(
      const vector<int> &cut_hyperedges, const graph &g,
      const vector<int> &parts,
      const flat_hash_map<int, set<pair<int, int>>> &net_insPin_set,
      HSFullTiming::HSPartitionFlow &pFlow,
      vector<SimpleTiming> &simpleTimingsCut, const bool &entireFlag,
      const int &l);
  static void contractionPath(const vector<int> &nodemap,
                              const vector<TimingPath> &timing_paths,
                              const vector<int> &hyperedge_cluster_id_vec,
                              vector<TimingPath> &timing_paths_c,
                              vector<set<int>> &ins_paths_c,
                              const bool &insPathFlag);
  static void getPathContraction(
      const vector<vector<int>> &maps,
      const vector<vector<int>> &hyperedge_cluster_id_vec_maps,
      const vector<graph> &graphs, const int &l,
      const vector<TimingPath> &cut_timing_paths,
      vector<TimingPath> &graphsl_timing_paths,
      vector<set<int>> &graphsl_ins_paths);
  static void newInfoMerge(vector<TimingPath> &timing_paths,
                           vector<set<int>> &ins_paths,
                           const vector<TimingPath> &timing_paths_newadd,
                           const bool &insPathFlag);
  static void propogateOld1(
      flat_hash_map<pair<int, int>, pinSlack> &pin_minslack,
      const vector<TimingPath> &finest_timing_paths,
      const flat_hash_map<pair<int, int>, vector<int>> &pin_paths,
      const pair<int, int> &pinid);
  static void propogateOld2(
      flat_hash_map<pair<int, int>, pinSlack> &pin_minslack,
      HSFullTiming::HSPartitionFlow &pFlow, const pair<int, int> &pinid);
  static void propogateNew(
      flat_hash_map<pair<int, int>, pinSlack> &pin_minslack,
      const pair<int, int> &pinid);
};

#endif