connecting graph partition with sbg

Author: francosansone

algorithms/partitioner/weighted_sb_graph.cpp

@@ -16,38 +16,69 @@
 
  ******************************************************************************/
 
-
 #include "weighted_sb_graph.hpp"
 
-
 using namespace std;
 
-
 namespace SBG {
 
 namespace LIB {
 
+WeightedSBGraph::WeightedSBGraph(WeightedSBGraph& graph)
+    : SBG(graph), _node_weights(graph.get_node_weights()), _edge_costs(graph.get_edge_costs())
+{
+}
+
+WeightedSBGraph::WeightedSBGraph(WeightedSBGraph&& graph)
+    : SBG(graph), _node_weights(graph.get_node_weights()), _edge_costs(graph.get_edge_costs())
+{
+}
+
+WeightedSBGraph::WeightedSBGraph(const Set& V, const PWMap& Vmap, const PWMap& map1, const PWMap& map2, const PWMap& Emap,
+                                 const PWMap& subEmap)
+    : SBG(V, Vmap, map1, map2, Emap, subEmap)
+{
+}
+
+WeightedSBGraph::~WeightedSBGraph() = default;
+
+void WeightedSBGraph::set_node_weights(NodeWeight& node_weights) { _node_weights = std::move(node_weights); }
+
+NodeWeight WeightedSBGraph::get_node_weights() const { return _node_weights; }
+
+void WeightedSBGraph::set_node_weight(const Set& node_set, int weight) { _node_weights[node_set] = weight; }
+
+int WeightedSBGraph::get_node_weight(const Set& node_set) const { return _node_weights.at(node_set); }
+
+void WeightedSBGraph::set_edge_costs(EdgeCost& edge_costs) { _edge_costs = std::move(edge_costs); }
+
+EdgeCost WeightedSBGraph::get_edge_costs() const { return _edge_costs; }
+
+void WeightedSBGraph::set_edge_cost(const Set& edge_set, unsigned cost) { _edge_costs[edge_set] = cost; }
+
+unsigned WeightedSBGraph::get_edge_cost(const Set& edge_set) const { return _edge_costs.at(edge_set); }
+
 ostream& operator<<(ostream& os, const WeightedSBGraph& graph)
 {
-    os << SBG(graph);
+  os << SBG(graph);
 
-    os << "node weight = << ";
-    for (const auto& [set, weight] : graph.get_node_weights()) {
-        os << set << " ↦ " << weight << ", ";
-    }
+  os << "node weight = << ";
+  for (const auto& [set, weight] : graph.get_node_weights()) {
+    os << set << " ↦ " << weight << ", ";
+  }
 
-    os << "\b >>" << endl;
+  os << "\b >>" << endl;
 
-    os << "edge costs = << ";
-    for (const auto& [set, weight] : graph.get_edge_costs()) {
-        os << set << " ↦ " << weight << ", ";
-    }
+  os << "edge costs = << ";
+  for (const auto& [set, weight] : graph.get_edge_costs()) {
+    os << set << " ↦ " << weight << ", ";
+  }
 
-    os << "\b >>" << endl;
+  os << "\b >>" << endl;
 
-    return os;
+  return os;
 }
 
-}
+}  // namespace LIB
 
-}
+}  // namespace SBG

algorithms/partitioner/weighted_sb_graph.hpp

@@ -21,8 +21,8 @@
 #include <map>
 #include <iostream>
 
-#include "sbg/sbg.hpp"
-#include "sbg/set.hpp"
+#include <sbg/sbg.hpp>
+#include <sbg/set.hpp>
 
 namespace SBG {
 
@@ -41,39 +41,36 @@ using NodeWeight = std::map<Set, int, setCompare>;
 class WeightedSBGraph : public SBG
 {
 public:
-    WeightedSBGraph(WeightedSBGraph& graph)
-        : SBG(graph),
-        _node_weights(graph.get_node_weights()),
-        _edge_costs(graph.get_edge_costs())
-    {}
-    WeightedSBGraph(WeightedSBGraph&& graph)
-        : SBG(graph),
-        _node_weights(graph.get_node_weights()),
-        _edge_costs(graph.get_edge_costs())
-    {}
+    WeightedSBGraph(WeightedSBGraph& graph);
+
+    WeightedSBGraph(WeightedSBGraph&& graph);
 
     WeightedSBGraph(const Set &V, const PWMap &Vmap
         , const PWMap &map1, const PWMap &map2
-        , const PWMap &Emap, const PWMap &subEmap)
-        : SBG(V, Vmap, map1, map2, Emap, subEmap)
-    {}
+        , const PWMap &Emap, const PWMap &subEmap);
+
+
+    WeightedSBGraph(const WeightedSBGraph&) = delete;
+    WeightedSBGraph operator=(WeightedSBGraph&& other) = delete;
+
+    ~WeightedSBGraph();
 
-    void set_node_weights(NodeWeight& node_weights) { _node_weights = std::move(node_weights); }
+    void set_node_weights(NodeWeight& node_weights);
 
-    NodeWeight get_node_weights() const { return _node_weights; }
+    NodeWeight get_node_weights() const;
 
-    void set_node_weight(const Set& node_set, int weight) { _node_weights[node_set] = weight; }
+    void set_node_weight(const Set& node_set, int weight);
 
-    int get_node_weight(const Set& node_set) const { return _node_weights.at(node_set); }
+    int get_node_weight(const Set& node_set) const;
 
 
-    void set_edge_costs(EdgeCost& edge_costs) { _edge_costs = std::move(edge_costs); }
+    void set_edge_costs(EdgeCost& edge_costs);
 
-    EdgeCost get_edge_costs() const { return _edge_costs; }
+    EdgeCost get_edge_costs() const;
 
-    void set_edge_cost(const Set& edge_set, unsigned cost) { _edge_costs[edge_set] = cost; }
+    void set_edge_cost(const Set& edge_set, unsigned cost);
 
-    unsigned get_edge_cost(const Set& edge_set) const { return _edge_costs.at(edge_set); }
+    unsigned get_edge_cost(const Set& edge_set) const;
 
 private:
     NodeWeight _node_weights;

test/partitioner/external_tools/graph_partitioner.cpp

@@ -37,15 +37,20 @@
 
 #include "graph_partitioner.hpp"
 #include <algorithms/partitioner/build_sb_graph.hpp>
+#include <algorithms/partitioner/kernighan_lin_partitioner.hpp>
+#include <algorithms/partitioner/partition_graph.hpp>
 #include <algorithms/partitioner/weighted_sb_graph.hpp>
 
-constexpr const char *VALID_PARTITION_METHODS = "{ Scotch, Metis, HMetis, Kahip}";
+constexpr const char *VALID_PARTITION_METHODS = "{ Scotch, Metis, HMetis, Kahip, SBG }";
 
 // Initialize the map outside the function
 static const std::unordered_map<std::string, PartitionMethod> PARTITION_METHOD_MAP = {{"Metis", PartitionMethod::Metis},
                                                                                       {"HMetis", PartitionMethod::HMetis},
                                                                                       {"Scotch", PartitionMethod::Scotch},
-                                                                                      {"Kahip", PartitionMethod::Kahip}};
+                                                                                      {"Kahip", PartitionMethod::Kahip},
+                                                                                      {"SBG", PartitionMethod::SBG}};
+
+static std::unique_ptr<SBG::LIB::WeightedSBGraph> sbg_graph;
 
 GraphPartitioner::GraphPartitioner(const std::string &name) : _name(name) { generateInputGraph(); }
 
@@ -95,6 +100,9 @@ Partition GraphPartitioner::createPartition(const std::string &partition_method_
     case PartitionMethod::Kahip:
       partitionUsingKaHip(partition);
       break;
+    case PartitionMethod::SBG:
+      partitionUsingSBG();
+      break;
     default:
       break;
     }
@@ -122,8 +130,9 @@ void GraphPartitioner::generateInputGraph()
 
 void GraphPartitioner::readGraphFromJson()
 {
-  auto sb_graph = sbg_partitioner::build_sb_graph(_name);
-  readGraphFromSBG(sb_graph);
+  auto temp_sbg_graph = sbg_partitioner::build_sb_graph(_name);
+  sbg_graph.reset(new SBG::LIB::WeightedSBGraph(temp_sbg_graph));
+  readGraphFromSBG();
 }
 
 void GraphPartitioner::readGraph()
@@ -314,13 +323,23 @@ void GraphPartitioner::partitionUsingKaHip(Partition &partition)
          partition.values.data());
 }
 
-void GraphPartitioner::readGraphFromSBG(const SBG::LIB::WeightedSBGraph &sbg_graph)
+void GraphPartitioner::partitionUsingSBG()
+{
+  std::cout << "partitionUsingSBG" << std::endl;
+
+  auto partitions = sbg_partitioner::best_initial_partition(*sbg_graph, _nbr_parts, sbg_partitioner::InitialPartitionStrategy::ALL, false);
+  // std::cout << "chosen partition " << partitions << std::endl;
+
+  sbg_partitioner::kl_sbg_imbalance_partitioner(*sbg_graph, partitions, _imbalance, false);
+}
+
+void GraphPartitioner::readGraphFromSBG()
 {
-  _nbr_vtxs = sbg_graph.V().cardinal();
-  _edges = sbg_graph.E().cardinal();
+  _nbr_vtxs = sbg_graph->V().cardinal();
+  _edges = sbg_graph->E().cardinal();
   // asumming all setpiece are unidimensional and have step 1
   int max_node = -1;
-  for (const auto &v : sbg_graph.V()) {
+  for (const auto &v : sbg_graph->V()) {
     if (int(v.begin()[0].end()) > max_node) {
       max_node = int(v.begin()[0].end());
     }
@@ -330,11 +349,11 @@ void GraphPartitioner::readGraphFromSBG(const SBG::LIB::WeightedSBGraph &sbg_gra
 
   for (int i = 0; i <= max_node; i++) {
     auto s = SBG::LIB::SET_FACT.createSet(SBG::LIB::Interval(i, 1, i));
-    auto edges1 = sbg_graph.map1().preImage(s);
-    auto nodes1 = sbg_graph.map2().image(edges1);
+    auto edges1 = sbg_graph->map1().preImage(s);
+    auto nodes1 = sbg_graph->map2().image(edges1);
 
-    auto edges2 = sbg_graph.map2().preImage(s);
-    auto nodes2 = sbg_graph.map1().image(edges2);
+    auto edges2 = sbg_graph->map2().preImage(s);
+    auto nodes2 = sbg_graph->map1().image(edges2);
 
     auto nodes = nodes1.cup(nodes2);
     auto nodes_vector = std::vector<int>();

test/partitioner/external_tools/graph_partitioner.hpp

@@ -17,12 +17,14 @@
 
  *****************************************************************************/
 
+#pragma once
+
 #include <vector>
 #include <string>
+#include <memory>
 #include <metis.h>
 #include <scotch/scotch.h>
 
-
 namespace SBG {
   namespace LIB {
     class WeightedSBGraph;
@@ -37,6 +39,7 @@ enum class PartitionMethod {
     HMetis,
     Scotch,
     Kahip,
+    SBG,
     Unknown
 };
 
@@ -70,14 +73,15 @@ class GraphPartitioner {
 
   void partitionUsingMetis(Partition &partition);
   void partitionUsingHMetis(Partition &partition);
+  void partitionUsingSBG();
   void createHMetisGraphFile(const std::string &file_name);
   void executeKhmetis(const std::string &h_graph_name) const;
 
   void partitionUsingScotch(Partition &partition);
 
   void partitionUsingKaHip(Partition &partition);
 
-  void readGraphFromSBG(const SBG::LIB::WeightedSBGraph& sbg_graph);
+  void readGraphFromSBG();
 
   std::string _name;
   grp_t _edges;

test/partitioner/external_tools/main.cpp

@@ -18,7 +18,7 @@
  *****************************************************************************/
 
 #include <algorithm>
-#include <filesystem>
+// #include <filesystem>
 #include <fstream>
 #include <getopt.h>
 #include <iostream>
@@ -80,12 +80,12 @@ int main(int argc, char* argv[])
   Partition partition = partitioner.createPartition(partition_method, partitions);
 
   // write results to a file
-  std::filesystem::path json_filesystem_path(json_file_name);
-  json_filesystem_path = json_filesystem_path.replace_extension();
-  std::ofstream output_file(json_filesystem_path.filename().string() + "_" + partition_method + "_" + std::to_string(partitions) +
-                            "_output.txt");
-  std::for_each(partition.values.cbegin(), partition.values.cend(),
-                [&output_file](const auto& val) { output_file << std::to_string(val) << "\n"; });
+  // std::filesystem::path json_filesystem_path(json_file_name);
+  // json_filesystem_path = json_filesystem_path.replace_extension();
+  // std::ofstream output_file(json_filesystem_path.filename().string() + "_" + partition_method + "_" + std::to_string(partitions) +
+  //                           "_output.txt");
+  // std::for_each(partition.values.cbegin(), partition.values.cend(),
+  //               [&output_file](const auto& val) { output_file << std::to_string(val) << "\n"; });
 
   return 0;
 }