improve time profile implementation

Author: francosansone

algorithms/partitioner/CMakeLists.txt

@@ -14,6 +14,7 @@ target_sources(
         partition_graph.cpp
         partition_metrics_api.cpp
         partition_strategy.cpp
+        time_profiler.cpp
         weighted_sb_graph.cpp
 )
 

algorithms/partitioner/kernighan_lin_partitioner.cpp

@@ -24,11 +24,11 @@
 #include "build_sb_graph.hpp"
 #include "communication_cost.hpp"
 #include "kernighan_lin_partitioner.hpp"
+#include "time_profiler.hpp"
 #include "sbg_partitioner_log.hpp"
 
 
 #define PARTITION_IMBALANCE_DEBUG 0
-#define PARTITION_IMBALANCE_PROFILE 0
 
 
 // This code is based on https://github.com/CIFASIS/sbg-partitioner/discussions/17
@@ -72,6 +72,7 @@ CostMatrixImbalance generate_gain_matrix(
     unsigned LMin,
     unsigned LMax)
 {
+    internal::TimeProfiler profiler("generate_gain_matrix");
     CostMatrixImbalance local_cost_matrix;
 
     for (size_t i = 0; i < partition_a.size(); i++) {
@@ -178,6 +179,7 @@ void update_diff(
     unsigned LMin,
     unsigned LMax)
 {
+    internal::TimeProfiler profiler("update_diff");
     logging::sbg_log << affected_node_a.first << ", " << affected_node_a.second << endl;
     logging::sbg_log << affected_node_b.first << ", " << affected_node_b.second << endl;
 
@@ -328,22 +330,14 @@ int kl_sbg_imbalance(
     Set b_v = graph.fact().createSet();
     const auto node_weights = graph.get_node_weights();
 
-    auto start_generate_gain_matrix = chrono::high_resolution_clock::now();
     CostMatrixImbalance gm = generate_gain_matrix(graph, cost_matrix, partition_a_id, partition_a, partition_b_id, partition_b, LMin, LMax);
-    auto end_generate_gain_matrix = chrono::high_resolution_clock::now();
-    auto time_to_generate_gain_matrix = chrono::duration<double, std::milli>(end_generate_gain_matrix - start_generate_gain_matrix).count();
-#if PARTITION_IMBALANCE_PROFILE
-    cout << "time_to_generate_gain_matrix: " << time_to_generate_gain_matrix << endl;
-#endif
-
 
 #if PARTITION_IMBALANCE_DEBUG
         logging::sbg_log << LMin << ", "
              << LMax
              << gm << endl;
 #endif
 
-    double time_to_update_diff = 0.;
     while ((not a_c.empty()) and (not b_c.empty())) {
         logging::sbg_log << "inside the while " << a_c << ", " << b_c << " ";
         logging::sbg_log << get_partition_size(a_c, node_weights, graph.fact()) << ", " << get_partition_size(b_c, node_weights, graph.fact()) << endl;
@@ -353,15 +347,9 @@ int kl_sbg_imbalance(
         logging::sbg_log << g << endl;
         pair<Set, Set> a_ = {graph.fact().createSet(), graph.fact().createSet()}, b_ = {graph.fact().createSet(), graph.fact().createSet()};
         tie(a_, b_) = update_sets(a_c, b_c, a_v, b_v, g, graph);
-        auto start_update_diff = chrono::high_resolution_clock::now();
         update_diff(gm, a_c, a_v, a_, b_c, b_v, b_, graph, node_weights, g, LMin, LMax);
-        auto end_update_diff = chrono::high_resolution_clock::now();
-        time_to_update_diff += chrono::duration<double, std::milli>(end_update_diff - start_update_diff).count();
         update_sum(par_sum, g.gain, max_par_sum, max_par_sum_set, a_v, b_v);
     }
-#if PARTITION_IMBALANCE_PROFILE
-    cout << "time_to_update_diff: " << time_to_update_diff << endl;
-#endif
 
     if (max_par_sum > 0) {
 

algorithms/partitioner/main.cpp

@@ -29,6 +29,7 @@
 #include "kernighan_lin_partitioner.hpp"
 #include "partition_graph.hpp"
 #include "partition_metrics_api.hpp"
+#include "time_profiler.hpp"
 
 
 using namespace std;
@@ -242,6 +243,9 @@ int main(int argc, char** argv)
         }
     }
 
+    // print profiler results if they are enabled
+    sbg_partitioner::time_profiler_results();
+
     cout << "time_to_build_graph = " << time_to_build_graph << " ms" << endl;
     cout << "time_to_partitionate = " << time_to_partitionate << " ms" << endl;
 

algorithms/partitioner/time_profiler.cpp

@@ -0,0 +1,65 @@
+/**
+ This file is part of Set--Based Graph Library.
+
+ SBG Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SBG Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SBG Library.  If not, see <http://www.gnu.org/licenses/>.
+
+ ******************************************************************************/
+
+ #include "time_profiler.hpp"
+
+namespace sbg_partitioner {
+
+void time_profiler_results()
+{
+    internal::TimeProfiler::print_execution_time();
+}
+
+
+namespace internal{
+
+std::unordered_map<std::string, double> TimeProfiler::_execution_time = {};
+
+TimeProfiler::TimeProfiler(std::string&& function_name)
+    : _function_name(move(function_name))
+{
+    if (time_profiler_enabled) {
+        _start = std::chrono::high_resolution_clock::now();
+    }
+}
+
+
+TimeProfiler::~TimeProfiler()
+{
+    if (time_profiler_enabled) {
+        auto end = std::chrono::high_resolution_clock::now();
+        auto exec_time = std::chrono::duration<double, std::milli>(end - _start).count();
+        if (_execution_time.find(_function_name) == _execution_time.end()) {
+            _execution_time.insert({_function_name, 0.0});
+        }
+        _execution_time[_function_name] += exec_time;
+    }
+}
+
+
+void TimeProfiler::print_execution_time() {
+    if (time_profiler_enabled) {
+        for (auto&& pair : TimeProfiler::_execution_time) {
+            std::cout << pair.first << ": " << pair.second << " ms" << std::endl;
+        }
+    }
+}
+
+}
+
+}

algorithms/partitioner/time_profiler.hpp

@@ -0,0 +1,49 @@
+/**
+ This file is part of Set--Based Graph Library.
+
+ SBG Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SBG Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SBG Library.  If not, see <http://www.gnu.org/licenses/>.
+
+ ******************************************************************************/
+
+ #include <chrono>
+ #include <iostream>
+ #include <string>
+ #include <unordered_map>
+
+ #pragma once
+
+namespace sbg_partitioner {
+
+constexpr bool time_profiler_enabled = false;
+
+void time_profiler_results();
+
+namespace internal {
+
+struct TimeProfiler {
+    TimeProfiler(std::string&& function_name);
+
+    ~TimeProfiler();
+
+    static void print_execution_time();
+
+private:
+    std::string _function_name;
+    std::chrono::_V2::system_clock::time_point _start;
+    static std::unordered_map<std::string, double> _execution_time;
+};
+
+}
+
+}