WIP, some changes to use an adjacency matrix to compute communication

Author: francosansone

algorithms/partitioner/build_sb_graph.cpp

@@ -365,7 +365,7 @@ Set get_edge_domain(Set image_intersection_set, Set& edge_set, int& max_value)
   return edge_domain_set;
 }
 
-tuple<Set, PWMap, PWMap, EdgeCost> create_graph_edges(const std::map<int, Node>& nodes, const map<int, int>& node_offsets, int& max_value)
+tuple<Set, PWMap, PWMap, EdgeCost> create_graph_edges(const std::map<int, Node>& nodes, const map<int, int>& node_offsets, int& max_value, bool compact_maps)
 {
   Set edge_set = SET_FACT.createSet();      // Our set of edges
   PWMap rhs_maps = PW_FACT.createPWMap();  // Map object of one of the sides
@@ -534,16 +534,18 @@ tuple<Set, PWMap, PWMap, EdgeCost> create_graph_edges(const std::map<int, Node>&
     }
   }
 
-  rhs_maps = rhs_maps.compact();
-  lhs_maps = lhs_maps.compact();
+  if (compact_maps) {
+    rhs_maps = rhs_maps.compact();
+    lhs_maps = lhs_maps.compact();
+  }
 
   return {edge_set, rhs_maps, lhs_maps, costs};
 }
 
 /// @brief  Add documentation
 /// @param nodes
 /// @return
-SBG::LIB::WeightedSBGraph create_sb_graph(const std::map<int, Node>& nodes)
+SBG::LIB::WeightedSBGraph create_sb_graph(const std::map<int, Node>& nodes, bool compact_maps)
 {
   int max_value = 0;  // We track the max value, so we avoid domain collision between edges and nodes
   map<int, int> node_offsets;
@@ -553,7 +555,7 @@ SBG::LIB::WeightedSBGraph create_sb_graph(const std::map<int, Node>& nodes)
   logging::sbg_log << "node_set " << node_set << endl;
 
   // Create edges and maps.
-  auto [edge_set, left_maps, right_maps, costs] = create_graph_edges(nodes, node_offsets, max_value);
+  auto [edge_set, left_maps, right_maps, costs] = create_graph_edges(nodes, node_offsets, max_value, compact_maps);
 
   // Now, let's create a graph
   SBG::LIB::WeightedSBGraph graph(node_set, PW_FACT.createPWMap(), left_maps, right_maps, PW_FACT.createPWMap(),
@@ -610,7 +612,7 @@ size_t get_set_size(const Set& set)
   return size;
 }
 
-SBG::LIB::WeightedSBGraph build_sb_graph(const string& filename)
+SBG::LIB::WeightedSBGraph build_sb_graph(const string& filename, bool compact_maps)
 {
   logging::sbg_log << "Reading " << filename << "..." << endl;
 
@@ -624,7 +626,7 @@ SBG::LIB::WeightedSBGraph build_sb_graph(const string& filename)
   auto nodes = create_node_objects_from_json(document);
 
   // Now, let's get our graph
-  auto graph = create_sb_graph(nodes);
+  auto graph = create_sb_graph(nodes, compact_maps);
 
   SBG_LOG << graph;
 

algorithms/partitioner/build_sb_graph.hpp

@@ -30,7 +30,7 @@ namespace sbg_partitioner {
 /// a node for each access to a variable and an edge for each connection
 /// between variables.
 /// If a variable appears on the left and on the right side, an edge is created.
-SBG::LIB::WeightedSBGraph build_sb_graph(const std::string& filename);
+SBG::LIB::WeightedSBGraph build_sb_graph(const std::string& filename, bool compact_maps = true);
 
 
 /// Ad hoc function to get pre image of an expression from its image.

algorithms/partitioner/communication_cost.cpp

@@ -23,6 +23,7 @@
 #include "communication_cost.hpp"
 #include "partition_graph.hpp"
 #include "partition_graph_cc.hpp"
+#include "sbg_partitioner_log.hpp"
 
 
 using namespace std;
@@ -48,6 +49,17 @@ std::size_t SetPieceHash::operator()(const SetPiece& set_piece) const {
   return seed;
 }
 
+
+std::size_t SetHash::operator()(const SBG::LIB::Set& set) const
+{
+    std::size_t seed = set.size();
+    for (const auto& set_piece : set) {
+        seed ^= SetPieceHash::set_piece_hash(set_piece) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+    }
+    return seed;
+}
+
+
 unordered_map<SetPiece, Set, SetPieceHash> CommunicationCost::_communication_by_set_piece = {};
 
 namespace internal {
@@ -70,7 +82,8 @@ Set set_piece_communication(const SetPiece& nodes, const WeightedSBGraph& graph)
     auto edges_map2 = graph.map2().preImage(node_set);
 
     // Now compute the disjoint union to remove loop edges
-    auto communication = edges_map1.cup(edges_map2).difference(edges_map1.intersection(edges_map2));
+    auto common_edges = edges_map1.intersection(edges_map2);
+    auto communication = edges_map1.cup(edges_map2).difference(common_edges);
 
     return communication;
 }
@@ -272,7 +285,7 @@ CommunicationCostCC::CommunicationCostCC(const WeightedSBGraph& graph, const usi
 
 void CommunicationCostCC::initialize()
 {
-    _adjacency_matrix = vector<vector<uint8_t> >(_sorted_nodes.size(), vector<uint8_t>(_sorted_nodes.size(), 0));
+    _adjacency_matrix = vector<vector<unsigned> >(_sorted_nodes.size(), vector<unsigned>(_sorted_nodes.size(), 0));
 
     for (size_t i = 0; i <  _sorted_nodes.size(); i++) {
         const auto& set_piece_pointer = _sorted_nodes.at(i);
@@ -283,6 +296,7 @@ void CommunicationCostCC::initialize()
             auto edges2 = get_set_piece_edges(set_piece_pointer_j.set_piece);
             auto shared_edges_cardinal = edges.intersection(edges2).cardinal();
             if (not edges.intersection(edges2).isEmpty()) {
+                logging::sbg_log << set_piece_pointer.set_piece << ", " << set_piece_pointer_j.set_piece << ": " << shared_edges_cardinal << endl;
                 _adjacency_matrix[set_piece_pointer.index][set_piece_pointer_j.index] = shared_edges_cardinal;
                 _adjacency_matrix[set_piece_pointer_j.index][set_piece_pointer.index] = shared_edges_cardinal;
             }
@@ -292,7 +306,7 @@ void CommunicationCostCC::initialize()
 #ifdef SBG_PARTITIONER_LOGGING
     for (size_t i = 0; i <  _sorted_nodes.size(); i++) {
         for (size_t j = 0; j < _sorted_nodes.size(); j++) {
-            cout << int(_adjacency_matrix[_sorted_nodes.at(i).index][_sorted_nodes.at(j).index]) << " ";
+            cout << unsigned(_adjacency_matrix[_sorted_nodes.at(i).index][_sorted_nodes.at(j).index]) << " ";
         }
         cout << endl;
     }

algorithms/partitioner/communication_cost.hpp

@@ -32,8 +32,13 @@
 namespace sbg_partitioner {
 
 struct SetPieceHash {
-  static std::size_t set_piece_hash(const SBG::LIB::SetPiece& set_piece);  
-  std::size_t operator()(const SBG::LIB::SetPiece& set_piece) const;
+    SetPieceHash() = default;
+    static std::size_t set_piece_hash(const SBG::LIB::SetPiece& set_piece);
+    std::size_t operator()(const SBG::LIB::SetPiece& set_piece) const;
+};
+
+struct SetHash {
+    std::size_t operator()(const SBG::LIB::Set& set_piece) const;
 };
 
 class ICommunicationCost {
@@ -169,7 +174,7 @@ class CommunicationCostCC {
 private:
     void initialize();
 
-    using AdjacencyMatrix = std::vector<std::vector<uint8_t>>;
+    using AdjacencyMatrix = std::vector<std::vector<unsigned>>;
 
     const SBG::LIB::WeightedSBGraph& _graph; // read-only members
 

algorithms/partitioner/main.cpp

@@ -23,9 +23,11 @@
 #include <getopt.h>
 #include <iostream>
 #include <optional>
+#include <set>
 #include <string>
 
 #include <algorithms/cc/cc.hpp>
+#include <sbg/set_fact.hpp>
 #include <util/time_profiler.hpp>
 
 #include "build_sb_graph.hpp"
@@ -151,7 +153,7 @@ void read_directory(const std::string& name, std::vector<std::string>& v)
 }
 
 
-tuple<unique_ptr<SBG::LIB::WeightedSBGraph>, PartitionMap, double, double> run_current_version(
+tuple<unique_ptr<SBG::LIB::WeightedSBGraph>, PartitionMap, double, double> partitionate_not_using_cc(
     const PartitionerParams& params)
 {
     auto start_build_graph = chrono::high_resolution_clock::now();
@@ -173,6 +175,93 @@ tuple<unique_ptr<SBG::LIB::WeightedSBGraph>, PartitionMap, double, double> run_c
 }
 
 
+tuple<unique_ptr<SBG::LIB::WeightedSBGraph>, PartitionMap, double, double> partitionate_using_cc(const PartitionerParams& params)
+{
+    auto start_build_graph = chrono::high_resolution_clock::now();
+    auto sb_graph = make_unique<SBG::LIB::WeightedSBGraph>(build_sb_graph(params.filename->c_str(), false));
+    auto end_build_graph = chrono::high_resolution_clock::now();
+    auto time_to_build_graph = chrono::duration<double, std::milli>(end_build_graph - start_build_graph).count();
+
+    cout << "sb_graph: " << *sb_graph << endl;
+
+    auto injective_conn = using_cc::split_nodes_into_injective_domains(*sb_graph);
+
+    logging::sbg_log << "injective connections " << injective_conn << endl;
+#if SBG_PARTITIONER_LOGGING
+    logging::sbg_log << "remaining " << sb_graph->V().difference(injective_conn) << endl;
+#endif
+
+    auto start_partitionate = chrono::high_resolution_clock::now();
+    using_cc::SetPointers sorted_nodes = {};
+    unsigned index = 0;
+    for (const auto& s : injective_conn) {
+        sorted_nodes.push_back(using_cc::SetPointer(index++, s, 0, s.cardinal()));
+    }
+
+    sbg_partitioner::CommunicationCostCC comm_cc(*sb_graph, sorted_nodes);
+
+    std::vector<sbg_partitioner::using_cc::SetPointers> sorted_partitions;
+    auto new_graph = SBG::LIB::WeightedSBGraph(
+        injective_conn,
+        sb_graph->Vmap(),
+        sb_graph->map1(),
+        sb_graph->map2(),
+        sb_graph->Emap(),
+        sb_graph->subEmap()
+    );
+
+    auto non_sorted_partitions = best_initial_partition(new_graph, *params.number_of_partitions, params.initial_partition_strategy, params.enable_multithreading);
+
+    // logging::sbg_log << "converting nodes into set pointers" << endl;
+    auto start_conversion = chrono::high_resolution_clock::now();
+    for (const auto& partition : non_sorted_partitions) {
+        sorted_partitions.emplace_back();
+        for (const auto& v : partition) {
+            for (const auto& n : sorted_nodes) {
+                if (not v.intersection(n.set_piece).isEmpty()) {
+                    size_t offset = v.begin()[0].begin() - n.set_piece.begin()[0].begin();
+                    sorted_partitions.back().emplace_back(n.index, n.set_piece, offset, v.cardinal());
+                }
+            }
+        }
+    }
+    auto end_conversion = chrono::high_resolution_clock::now();
+    auto conversion_time = chrono::duration<double, std::milli>(end_conversion - start_conversion).count();
+    // auto sorted_partitions = using_cc::best_initial_partition(*sb_graph, sorted_nodes, comm_cc, *params.number_of_partitions, InitialPartitionStrategy::DFS_DISTRIBUTIVE_POSTORDER);
+    for (const auto& sp : sorted_partitions){
+        cout << sp << endl;
+    }
+
+    for (size_t i = 0; i < sorted_nodes.size(); i++) {
+        const auto& s1 = sorted_nodes.at(i);
+        for (size_t j = i + 1; j < sorted_nodes.size(); j++) {
+            const auto& s2 = sorted_nodes.at(j);
+
+            auto comm = comm_cc.get_communication(s1.index, s2.index);
+            cout << s1.set_piece << " " <<  s1.set_piece.cardinal() << " - " << s2.set_piece << " " <<  s2.set_piece.cardinal() << ": " << comm << endl;
+            if (comm > 0) {
+                assert(s1.set_piece.cardinal() == s2.set_piece.cardinal());
+            }
+        }
+    }
+
+    sanity_check(*sb_graph, sbg_partitioner::using_cc::rebuild_partitions(sorted_nodes, sorted_partitions), *params.number_of_partitions);
+
+    using_cc::kl_sbg_imbalance_partitioner(*sb_graph, sorted_nodes, sorted_partitions, comm_cc, 0.);
+
+    auto partitions = sbg_partitioner::using_cc::rebuild_partitions(sorted_nodes, sorted_partitions);
+    auto end_partitionate = chrono::high_resolution_clock::now();
+    auto time_to_partitionate = chrono::duration<double, std::milli>(end_partitionate - start_partitionate).count();
+    time_to_partitionate -= conversion_time;
+
+    // if (sanity_check_enabled) {
+        sanity_check(*sb_graph, partitions, *params.number_of_partitions);
+    // }
+
+    return { move(sb_graph), partitions, time_to_build_graph, time_to_partitionate };
+}
+
+
 static struct option long_options[] = {{"config-filename", required_argument, 0, 'c'},
                                        {"filename", required_argument, 0, 'f'},    {"partitions", required_argument, 0, 'p'},
                                        {"output-file", required_argument, 0, 'g'}, {"output-graph", required_argument, 0, 'o'},
@@ -316,57 +405,9 @@ int main(int argc, char** argv)
     PartitionMap partitions;
     double time_to_build_graph, time_to_partitionate = 0.0;
     if (not params.use_connected_components) {
-        tie(sb_graph, partitions, time_to_build_graph, time_to_partitionate) = run_current_version(params);
+        tie(sb_graph, partitions, time_to_build_graph, time_to_partitionate) = partitionate_not_using_cc(params);
     } else {
-        auto start_build_graph = chrono::high_resolution_clock::now();
-        sb_graph = make_unique<SBG::LIB::WeightedSBGraph>(build_sb_graph(params.filename->c_str()));
-        auto end_build_graph = chrono::high_resolution_clock::now();
-        time_to_build_graph = chrono::duration<double, std::milli>(end_build_graph - start_build_graph).count();
-
-        auto cc_pw_map = SBG::LIB::connectedComponents(*sb_graph);
-
-        cout << "sb_graph: " << *sb_graph << endl;
-        cout << cc_pw_map.dom() << endl;
-
-        using_cc::SetPointers sorted_nodes = {};
-        unsigned index = 0;
-        for (const auto& s : cc_pw_map.dom()) {
-            sorted_nodes.push_back(using_cc::SetPointer(index++, s, s.cardinal()));
-        }
-
-        sbg_partitioner::CommunicationCostCC comm_cc(*sb_graph, sorted_nodes);
-
-        auto new_graph = SBG::LIB::WeightedSBGraph(
-            cc_pw_map.dom(),
-            sb_graph->Vmap(),
-            sb_graph->map1(),
-            sb_graph->map2(),
-            sb_graph->Emap(),
-            sb_graph->subEmap()
-        );
-
-        vector<using_cc::SetPointers> sorted_partitions;
-        auto non_sorted_partitions = best_initial_partition(new_graph, *params.number_of_partitions, params.initial_partition_strategy, params.enable_multithreading);
-
-        for(const auto& partition : non_sorted_partitions) {
-            sorted_partitions.emplace_back();
-            for (const auto& s : partition) {
-                for (const auto& ss : sorted_nodes) {
-                    if (not s.intersection(ss.set_piece).isEmpty()) {
-                        sorted_partitions.back().emplace_back(ss.index, ss.set_piece, s.cardinal());
-                        break;
-                    }
-                }
-            }
-        }
-
-        partitions = sbg_partitioner::using_cc::rebuild_partitions(sorted_nodes, sorted_partitions);
-        sanity_check(*sb_graph, partitions, *params.number_of_partitions);
-
-        sbg_partitioner::using_cc::kl_sbg_imbalance_partitioner(*sb_graph, sorted_nodes, sorted_partitions, comm_cc, 0.);
-
-        partitions = sbg_partitioner::using_cc::rebuild_partitions(sorted_nodes, sorted_partitions);
-        sanity_check(*sb_graph, partitions, *params.number_of_partitions);
+        tie(sb_graph, partitions, time_to_build_graph, time_to_partitionate) = partitionate_using_cc(params);
     }
 
     if (not sb_graph) {

algorithms/partitioner/partition_graph.cpp

@@ -155,13 +155,16 @@ Partition to_vector(const Set& partition_set)
 
 
 PartitionMap best_initial_partition(WeightedSBGraph& graph, unsigned number_of_partitions,
-    const InitialPartitionStrategy strategy, bool multithreading_enabled)
+    const InitialPartitionStrategy strategy, bool multithreading_enabled, bool create_comm_cost)
 {
   logging::sbg_log << "computing strategy number " << strategy << endl;
   std::vector<sbg_partitioner::PartitionMap> partition_maps = make_initial_partitions(graph, number_of_partitions, strategy);
 
   auto& best_initial_partitions = partition_maps.front();
-  CommunicationCostPtr comm_cost = create_communication_cost(graph, best_initial_partitions, multithreading_enabled);
+  CommunicationCostPtr comm_cost;
+  if (create_comm_cost) {
+    comm_cost = create_communication_cost(graph, best_initial_partitions, multithreading_enabled);
+  }
   if (strategy == InitialPartitionStrategy::ALL) {
 
     auto best_communication_set = SET_FACT.createSet();
@@ -190,7 +193,9 @@ PartitionMap best_initial_partition(WeightedSBGraph& graph, unsigned number_of_p
     logging::sbg_log << "Best is " << best_initial_partitions << " with communication " << best_communication_set << endl;
   }
 
-  set_communication_cost(move(comm_cost));
+  if (create_comm_cost) {
+    set_communication_cost(move(comm_cost));
+  }
 
   return best_initial_partitions;
 }
@@ -209,21 +214,22 @@ Set get_connectivity_set(SBG::LIB::SBG& graph, const PartitionMap& partitions, s
 }
 
 
-void sanity_check(const WeightedSBGraph& graph, PartitionMap& partitions_set, unsigned number_of_partitions)
+void sanity_check(const WeightedSBGraph& graph, const PartitionMap& partitions_set, unsigned number_of_partitions)
 {
-  cout << "\nsanity_check\n" << partitions_set << endl;
   // This is just a sanity check
   Set nodes_to_check = SET_FACT.createSet();
   for (unsigned i = 0; i < number_of_partitions; i++) {
-    nodes_to_check = nodes_to_check.cup(from_vector(partitions_set[i]));
+    auto s_i = from_vector(partitions_set[i]);
+    assert(s_i.intersection(nodes_to_check).isEmpty());
+    nodes_to_check = nodes_to_check.cup(s_i);
   }
 
   Set diff = nodes_to_check.difference(graph.V());
-  cout << "diff1 " << diff << endl;
+  logging::sbg_log << "diff1 " << diff << endl;
   assert(get_node_size(diff, graph.get_node_weights()) == 0 and "The intial partition has more elements than the graph");
 
   diff = graph.V().difference(nodes_to_check);
-  cout << "diff2 " << diff << endl;
+  logging::sbg_log << "diff2 " << diff << endl;
   assert(get_node_size(diff, graph.get_node_weights()) == 0 and "The intial partition has less elements than the graph");
 
   for (unsigned i = 0; i < number_of_partitions; i++) {