.. _program_listing_file_src_partition_tools.h:

Program Listing for File tools.h
================================

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

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

.. code-block:: cpp

   #ifndef TOOLS_H
   #define TOOLS_H
   
   #include "../modeling/tool.h"
   #include "../sta/HSCutNetFlow.h"
   #include "../sta/HSPartitionFlow.h"
   #include "../sta/HSTimingLocalData.h"
   #include "defs.h"
   
   
   bool floatNumEqual(const float &v1, const float &v2);
   
   bool floatNumLess(const float &v1, const float &v2);
   
   int compute_group_constrain(
       const graph &finest,
       const unordered_map<string, vector<string>> &group_assignment,
       const flat_hash_map<string, int> &name_map, vector<int> &group_map);
   
   bool checkFixTopo(const graph &circuit, const vector<int> &fixed_assign,
                     const vector<vector<int>> &topology);
   
   double tdm_delay(double tdm_ratio);
   
   void calculateSmallestDelayPaths(const graph &g, const vector<int> &parts,
                                    const fpga &fpgas, vector<vector<double>> &tdm,
                                    vector<vector<vector<int>>> &paths);
   
   void getPinMinslackC(const graph &fine, const int &e,
                        const vector<int> &hyperedge_cluster_id_vec,
                        const vector<int> &map,
                        flat_hash_map<pair<int, int>, pinSlack> &pin_minslack_c);
   
   void readPartitionResult(vector<int> &parts,
                            const string &partition_result_file);
   
   string formatHierarchyPath(const vector<int> &path);
   
   inline constexpr double kMaxHierarchyResourceSlack = 2.0;
   
   void collectLeafResources(const hierarchy &node, fpga &flat_fpgas);
   
   bool applyLeafResources(hierarchy &node, const vector<VectorXi> &flat_resources,
                           int &cursor);
   
   vector<bool> getDistributedResourceDims(
       const vector<int> &required_resources,
       const vector<VectorXi> &full_leaf_resources);
   
   vector<double> computeHierarchySlacks(
       const vector<int> &required_resources,
       const vector<VectorXi> &full_leaf_resources,
       const vector<bool> &distributed_dims);
   
   bool aggregateHierarchyResourcesWithDistributedSlack(
       hierarchy &node, int consumed_levels, const vector<bool> &distributed_dims,
       const vector<double> &resource_slacks);
   
   void writeHierarchyPartitionArtifacts(
       const graph &finest, const hierarchy &hierarchy_root,
       const vector<vector<int>> &node_paths,
       const vector<HierarchyPartitionCutRecord> &cut_records,
       const string &parts_filename, const string &aux_filename);
   
   vector<CutConnection> convertSubConnetsToCutConnections(
       const vector<shared_ptr<CONNET>> &subConnets);
   
   bool convertCutNetPathsToSimpleTimings(
       const HSFullTiming::HSCutNetFlow &cutNetFlow,
       const vector<HSFullTiming::HSCutNetFlow::CutNetTimingPath> &cutNetPaths,
       vector<SimpleTiming> &converted);
   
   void evaluatePartitionTimingComparison(const graph &finest, fpga &fpgas,
                                          const vector<int> &parts,
                                          HSFullTiming::HSPartitionFlow &pFlow,
                                          int topk);
   #endif