temporal change with many lines of code commented to test edge-cut values

Author: francosansone

algorithms/partitioner/main.cpp

@@ -201,7 +201,7 @@ tuple<unique_ptr<SBG::LIB::WeightedSBGraph>, PartitionMap, double, double> parti
       best_initial_partition(sb_graph, *params.number_of_partitions, params.initial_partition_strategy, params.enable_multithreading);
   cout << "chosen partition " << partitions << endl;
 
-  kl_sbg_imbalance_partitioner(sb_graph, partitions, params.epsilon, params.enable_multithreading);
+  // kl_sbg_imbalance_partitioner(sb_graph, partitions, params.epsilon, params.enable_multithreading);
   auto end_partitionate = chrono::high_resolution_clock::now();
   auto time_to_partitionate = chrono::duration<double, std::milli>(end_partitionate - start_partitionate).count();
 
@@ -436,36 +436,42 @@ int main(int argc, char** argv)
   if (params.compute_metrics) {
     map<string, metrics::communication_metrics> metrics;
 
-    int edge_cut = metrics::edge_cut(partitions, *sb_graph);
+    // int edge_cut = metrics::edge_cut(partitions, *sb_graph);
 
-    auto [comm_volume, max_comm_volume] = metrics::communication_volume(partitions, *sb_graph);
+    // auto [comm_volume, max_comm_volume] = metrics::communication_volume(partitions, *sb_graph);
 
-    auto max_imb = metrics::maximum_imbalance(partitions, *sb_graph);
+    // auto max_imb = metrics::maximum_imbalance(partitions, *sb_graph);
 
-    metrics::communication_metrics comm_metrics = metrics::communication_metrics{edge_cut, comm_volume, max_comm_volume, max_imb};
-    metrics["sbg-partitioner"] = comm_metrics;
-
-    for (const auto& [f, m] : metrics) {
-      cout << f << ": " << m << endl;
-    }
+    // metrics::communication_metrics comm_metrics = metrics::communication_metrics{edge_cut, comm_volume, max_comm_volume, max_imb};
+    // metrics["sbg-partitioner"] = comm_metrics;
 
     if (params.compute_metrics and params.directory) {
       std::vector<std::string> dir_files;
       read_directory(*params.directory, dir_files);
 
       for (const auto& f : dir_files) {
-        auto partition_from_file = metrics::read_partition_from_file(f, *sb_graph);
+        if(f.substr(f.find_last_of(".") + 1) == "csv") {
+          cout << "Ignoring " << f << endl;
+          continue;
+        }
+        cout << f << endl;
+
+        auto partition_from_file = metrics::read_partition_from_file(f, *sb_graph, *params.number_of_partitions);
 
         int edge_cut = metrics::edge_cut(partition_from_file, *sb_graph);
 
-        auto [comm_volume, max_comm_volume] = metrics::communication_volume(partition_from_file, *sb_graph);
+        // auto [comm_volume, max_comm_volume] = metrics::communication_volume(partition_from_file, *sb_graph);
 
-        auto max_imb = metrics::maximum_imbalance(partition_from_file, *sb_graph);
+        // auto max_imb = metrics::maximum_imbalance(partition_from_file, *sb_graph);
 
-        metrics::communication_metrics comm_metrics = metrics::communication_metrics{edge_cut, comm_volume, max_comm_volume, max_imb};
+        metrics::communication_metrics comm_metrics = metrics::communication_metrics{edge_cut, 0, 0, 0};
         metrics[std::filesystem::path(f).filename().string()] = comm_metrics;
       }
     }
+
+    for (const auto& [f, m] : metrics) {
+      cout << f << ": " << m << endl;
+    }
   }
 
   // print profiler results if they are enabled

algorithms/partitioner/partition_metrics_api.cpp

@@ -128,16 +128,19 @@ void write_node_by_partition(const PartitionMap& partitions, const WeightedSBGra
 
 int edge_cut(const PartitionMap& partitions, const WeightedSBGraph& sb_graph)
 {
+    cout << "computing edge cut " << endl;
     Set ec = SET_FACT.createSet();
     const auto& maps_1 = sb_graph.map1();
     const auto& maps_2 = sb_graph.map2();
     for (size_t i = 0; i < partitions.size(); i++) {
+        cout << "partition " << i << endl;
         Set partition = from_vector(partitions.at(i));
         ec = ec.cup(get_edge_cut(partition, maps_1, maps_2));
         ec = ec.cup(get_edge_cut(partition, maps_2, maps_1));
     }
 
     int weight = get_edge_set_cost(ec, sb_graph.get_edge_costs());
+    cout << "ec is " << weight << endl;
 
     return weight;
 }
@@ -181,28 +184,22 @@ float maximum_imbalance(const PartitionMap& partitions, const WeightedSBGraph& s
 }
 
 
-PartitionMap read_partition_from_file(const string& name, const WeightedSBGraph& sb_graph)
+PartitionMap read_partition_from_file(const string& name, const WeightedSBGraph& sb_graph, int number_of_partitions)
 {
 
     ifstream file(name);
     string line; // String to store each line of the file.
 
-    PartitionMap partitions;
+    PartitionMap partitions(number_of_partitions, Partition());
     if (file.is_open()) {
         // Read each line from the file and store it in the
         // 'line' variable.
         int node_counter = 0;
         while (getline(file, line)) {
-            partitions.push_back({Interval(node_counter, 1, node_counter)});
+            partitions[stoi(line)].push_back({Interval(node_counter, 1, node_counter)});
             node_counter++;
         }
 
-        for (auto& s: partitions) {
-            auto s_set = from_vector(s);
-            flatten_set(s_set, sb_graph);
-            s = to_vector(s_set);
-        }
-
         // Close the file stream once all lines have been
         // read.
         file.close();

algorithms/partitioner/partition_metrics_api.hpp

@@ -41,7 +41,7 @@ std::pair<int, int> communication_volume(
 
 float maximum_imbalance(const PartitionMap& partitions, const SBG::LIB::WeightedSBGraph& sb_graph);
 
-PartitionMap read_partition_from_file(const std::string& name, const SBG::LIB::WeightedSBGraph& sb_graph);
+PartitionMap read_partition_from_file(const std::string& name, const SBG::LIB::WeightedSBGraph& sb_graph, int number_of_partitions);
 
 std::ostream& operator<<(std::ostream& os, const communication_metrics& comm_metrics);
 }