Program Listing for File tools.h

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

#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