prepare benchmarking

Author: francosansone

test/partitioner/external_tools/graph_partitioner.cpp

@@ -20,7 +20,6 @@
 #include <array>
 #include <algorithm>
 #include <cassert>
-#include <chrono>
 #include <cstdlib>
 #include <fstream>
 #include <iostream>
@@ -39,6 +38,7 @@
 #include <algorithms/partitioner/build_sb_graph.hpp>
 #include <algorithms/partitioner/kernighan_lin_partitioner.hpp>
 #include <algorithms/partitioner/partition_graph.hpp>
+#include <algorithms/partitioner/sbg_partitioner_types.hpp>
 #include <algorithms/partitioner/weighted_sb_graph.hpp>
 
 constexpr const char *VALID_PARTITION_METHODS = "{ Scotch, Metis, HMetis, Kahip, SBG }";
@@ -68,14 +68,15 @@ std::string GraphPartitioner::validPartitionMethodsStr()
   return valid_methods.str();
 }
 
-Partition GraphPartitioner::createPartition(const std::string &partition_method_name, unsigned int partitions)
+std::tuple<Partition, std::chrono::duration<double>> GraphPartitioner::createPartition(const std::string &partition_method_name,
+                                                                                       unsigned int partitions, bool save_to_file)
 {
   Partition partition;
   PartitionMethod partition_method = partitionMethod(partition_method_name);
 
   if (partition_method == PartitionMethod::Unknown) {
     std::cerr << "Unknown partition method, valid values are: " << validPartitionMethodsStr() << std::endl;
-    return partition;
+    return {partition, std::chrono::duration<double>()};
   }
 
   partition.resize(_nbr_vtxs);
@@ -84,6 +85,10 @@ Partition GraphPartitioner::createPartition(const std::string &partition_method_
 
   partition.resize(_nbr_vtxs);
 
+  // just in case we are using sbg
+  sbg_partitioner::PartitionMap sbg_partitions = {};
+  sbg_partitions.resize(_nbr_parts);
+
   auto start = std::chrono::high_resolution_clock::now();
 
   if (_nbr_vtxs > _nbr_parts) {
@@ -101,7 +106,7 @@ Partition GraphPartitioner::createPartition(const std::string &partition_method_
       partitionUsingKaHip(partition);
       break;
     case PartitionMethod::SBG:
-      partitionUsingSBG();
+      partitionUsingSBG(sbg_partitions);
       break;
     default:
       break;
@@ -113,8 +118,15 @@ Partition GraphPartitioner::createPartition(const std::string &partition_method_
 
   std::cout << "Partition Time: " << duration.count() << " seconds." << std::endl;
 
-  savePartitionToFile(partition, partition_method_name);
-  return partition;
+  if (save_to_file) {
+    if (partition_method == PartitionMethod::SBG) {
+      // do something
+    } else {
+      savePartitionToFile(partition, partition_method_name);
+    }
+  }
+
+  return {partition, duration};
 }
 
 bool GraphPartitioner::endsWithJson() { return _name.size() >= 5 && _name.compare(_name.size() - 5, 5, ".json") == 0; }
@@ -323,11 +335,9 @@ void GraphPartitioner::partitionUsingKaHip(Partition &partition)
          partition.values.data());
 }
 
-void GraphPartitioner::partitionUsingSBG()
+void GraphPartitioner::partitionUsingSBG(sbg_partitioner::PartitionMap &partitions)
 {
-  std::cout << "partitionUsingSBG" << std::endl;
-
-  auto partitions = sbg_partitioner::best_initial_partition(*sbg_graph, _nbr_parts, sbg_partitioner::InitialPartitionStrategy::ALL, false);
+  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);

test/partitioner/external_tools/graph_partitioner.hpp

@@ -19,19 +19,21 @@
 
 #pragma once
 
+#include <chrono>
 #include <vector>
 #include <string>
 #include <memory>
 #include <metis.h>
 #include <scotch/scotch.h>
 
+#include <algorithms/partitioner/sbg_partitioner_types.hpp>
+
 namespace SBG {
   namespace LIB {
     class WeightedSBGraph;
   }
 }
 
-
 using grp_t = int;
 
 enum class PartitionMethod {
@@ -54,7 +56,7 @@ class GraphPartitioner {
   public:
   explicit GraphPartitioner(const std::string &name);
 
-  Partition createPartition(const std::string& partition_method, unsigned int partitions);
+  std::tuple<Partition, std::chrono::duration<double>> createPartition(const std::string& partition_method, unsigned int partitions, bool save_to_file);
 
   static std::string validPartitionMethodsStr();
 
@@ -73,7 +75,7 @@ class GraphPartitioner {
 
   void partitionUsingMetis(Partition &partition);
   void partitionUsingHMetis(Partition &partition);
-  void partitionUsingSBG();
+  void partitionUsingSBG(sbg_partitioner::PartitionMap& partitions);
   void createHMetisGraphFile(const std::string &file_name);
   void executeKhmetis(const std::string &h_graph_name) const;
 

test/partitioner/external_tools/main.cpp

@@ -18,14 +18,17 @@
  *****************************************************************************/
 
 #include <algorithm>
-// #include <filesystem>
+#include <filesystem>
 #include <fstream>
 #include <getopt.h>
 #include <iostream>
 #include <vector>
 
 #include "graph_partitioner.hpp"
 
+static int number_of_executions = 15;
+static int number_of_cold_executions = 5;
+
 void usage()
 {
   std::cout << "Usage: grap_partitioner -f <file_name> -n <num_partitions> -m <partition_method> -i <imbalance>" << std::endl;
@@ -67,6 +70,40 @@ void parseArgs(int argc, char* argv[], std::string& sbg_json_input, int& partiti
   }
 }
 
+void addRecord(const std::string& filename, const std::string& method, int partitions,
+               const std::vector<std::chrono::duration<double>>& durations)
+{
+  // Check if the file already exists before we open it
+  bool exists = std::filesystem::exists(filename);
+
+  // Open in append mode
+  std::ofstream myFile(filename, std::ios::app);
+
+  if (!myFile.is_open()) {
+    std::cerr << "Error opening file!" << std::endl;
+    return;
+  }
+
+  // If the file is new, write the header first
+  if (!exists) {
+    myFile << "Method,Partitions";
+    for (size_t i = 0; i < number_of_executions - number_of_cold_executions; i++) {
+      myFile << ", exec " << i;
+    }
+    myFile << "\n";
+  }
+
+  // Add the new row
+  myFile << method << "," << partitions;
+  for (const auto& d : durations) {
+    myFile << "," << d.count();
+  }
+  myFile << "\n";
+
+  myFile.close();
+  std::cout << "Results in " << filename << std::endl;
+}
+
 int main(int argc, char* argv[])
 {
   std::string json_file_name;
@@ -76,8 +113,22 @@ int main(int argc, char* argv[])
 
   parseArgs(argc, argv, json_file_name, partitions, partition_method, imbalance);
 
-  GraphPartitioner partitioner(json_file_name);
-  Partition partition = partitioner.createPartition(partition_method, partitions);
+  std::vector<std::chrono::duration<double>> durations;
+
+  for (size_t i = 0; i < number_of_executions; i++) {
+    GraphPartitioner partitioner(json_file_name);
+    auto [partition, duration] = partitioner.createPartition(partition_method, partitions, i == number_of_executions - 1);
+
+    if (i < number_of_cold_executions) {
+      continue;
+    }
+
+    durations.push_back(duration);
+  }
+
+  std::filesystem::path json_file_name_path(json_file_name);
+
+  addRecord(json_file_name_path.filename().replace_extension("csv"), partition_method, partitions, durations);
 
   // write results to a file
   // std::filesystem::path json_filesystem_path(json_file_name);