Program Listing for File coarsen.h

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

#ifndef COARSEN_H
#define COARSEN_H

#include "defs.h"
#include "evaluator.h"
#include "tools.h"

using namespace std;


enum class CoarsenOrder {
  RANDOM,
  DEGREE,
  SIZE,
  TIMING,
  DEFAULT
};

struct ContractedHyperedgeInformation {
  int he = -1;
  unsigned long long hash =
      42ULL;
  size_t size = std::numeric_limits<size_t>::
      max();
  bool valid = false;
};

class MultilevelCoarsener {
 private:
  const fpga &fpgas;
  int fpga_num;
  int index;
  int multilevel_id =
      0;

  bool
      has_fix;
  bool has_region;
  bool has_io;
  bool force_topo;
  bool has_timing;

  int large_net_threshold;
  int beta;
  double
      coarsening_ratio;
  int coarsen_method = 1;
  int enable_weight_penalty =
      0;
  int thr_coarsen_vertice;

  int seed =
      0;
  int thread;
  VectorXi
      resources_in_one_FPGA;
  CoarsenOrder coarsen_order =
      CoarsenOrder::SIZE;

  kahypar::SparseMap<int, float>
      score_map;
  kahypar::SparseMap<int, float>
      matched_score_map;
  vector<net> tmp_nets;
  vector<int> tmp_incident_nodes;
  vector<vector<int>>
      hyperedge_cluster_id_vec_maps;

  //   float timing_exp_factor;
  //   float net_timing_factor_coarse;
  //   shared_ptr<timingEvaluator> evaluator = nullptr;

  void calTimingPathForGroup(
      const vector<TimingPath> &timing_paths, const vector<int> &map,
      const vector<int> &hyperedge_cluster_id_vec, graph &coarse,
      vector<TimingPath> &timing_paths_c, vector<set<int>> &ins_paths_c,
      flat_hash_map<int, set<pair<int, int>>> &net_insPin_set_c);

  void computeGroupGraph(const graph &finest, int index,
                         const vector<int> &group_map, graph &coarse);
  void candidatePropagation();
  set<int> intersection(const set<int> &set1, const set<int> &set2);

  void coarsening(int l);
  void contraction(int l);
  void parallelContraction(int l);

 public:
  int level;
  vector<int>
      isolated_nodes;
  vector<graph> graphs;
  vector<vector<int>>
      maps;
  vector<vector<int>> map2origins;

  int buildGroupedGraph(const graph &finest, int group_count,
                        const vector<int> &group_map, graph &grouped);

  void deduplicateHyperedges(graph &finest);

  void setCoarsenOrder(int s);

  void setMultilevelId(int id);

  int getMultilevelId() const;

  int COCP_coarsen(const graph &finest, vector<vector<int>> &candidate_parts,
                   int thr_ilp);

  MultilevelCoarsener(const graph &finest, const fpga &fpgas,
                      const PartitionConstraintConfig &constraints,
                      const CoarsenConfig &config, int thread);

  void multilevelCoarsening(const graph &finest);
};

#endif