Program Listing for File initial.h

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

#ifndef INITIAL_H
#define INITIAL_H

#include "coarsen.h"
#include "ortools/linear_solver/linear_solver.h"
#include "refine/bucket/MoveBucket.h"
#include "refine/core/RefineTypes.h"


class Initial {
 private:
  bool has_fix;
  bool force_topo;
  int multilevel_id = 0;
  int max_hop;
  int num_initial_solutions;
  int num_best_initial_solutions;

  vector<flat_hash_map<int, pair<int, double>>>
      hypergraph;

  void constructGraph(const graph &g);

  void improvedSPFA(const graph &g, vector<int> &parts,
                    vector<VectorXi> upper_resources,
                    vector<VectorXi> &occupied_resources);

  int selectInitialNodes(const graph &g, vector<int> &parts,
                         vector<VectorXi> upper_resources,
                         vector<VectorXi> &occupied_resources,
                         vector<int> &order);

  int randomPart(const graph &g, vector<int> &parts, VectorXi upper_resources,
                 VectorXi lower_resources, vector<VectorXi> &occupied_resources,
                 int seed);

  int greedyPart(const graph &g, vector<int> &parts,
                 vector<VectorXi> upper_resources,
                 vector<VectorXi> &occupied_resources, int seed);

  int progressiveMinCutPart(const graph &g, vector<int> &parts,
                            vector<VectorXi> upper_resources,
                            vector<VectorXi> &occupied_resources, int seed);

  double calculateGain(const graph &g, const vector<int> &parts, int vertex,
                       int to, int type);

  int growPart(const graph &g, vector<int> &parts,
               vector<VectorXi> upper_resources,
               vector<VectorXi> &occupied_resources, int i, int seed);

  int globalGrowPart(const graph &g, vector<int> &parts,
                     vector<VectorXi> upper_resources,
                     vector<VectorXi> &occupied_resources, int type, int seed);

  int sequentialGrowPart(const graph &g, vector<int> &parts,
                         vector<VectorXi> upper_resources,
                         vector<VectorXi> &occupied_resources, int type,
                         int seed);

  int roundRobinGrowPart(const graph &g, vector<int> &parts,
                         vector<VectorXi> upper_resources,
                         vector<VectorXi> &occupied_resources, int type,
                         int seed);

  int initialPartitionTopo(const graph &g, const fpga &fpgas,
                           vector<int> &parts, vector<VectorXi> upper_resources,
                           vector<VectorXi> &occupied_resources, bool has_fix,
                           const vector<int> &fixed_assign,
                           vector<set<int>> candidate, int allow_hop, int i,
                           int seed);

 public:
  Initial(const PartitionConstraintConfig &constraints,
          const InitialPartitionConfig &config);

  int initialPartition(MultilevelCoarsener &mc, const fpga &fpgas,
                       vector<vector<int>> &candidate_parts,
                       vector<vector<VectorXi>> &candidate_occupied_resources);

  bool COCP_ILP(MultilevelCoarsener &mc, const fpga &fpgas, bool has_fix,
                vector<int> &candidate_parts,
                vector<VectorXi> &candidate_occupied_resources);
};

#endif