.. _program_listing_file_src_partition_evaluator.h:

Program Listing for File evaluator.h
====================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_partition_evaluator.h>` (``src/partition/evaluator.h``)

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

.. code-block:: cpp

   #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