one line if

Author: tonibohnlein

apps/coarser_plotter.cpp

@@ -62,13 +62,17 @@ int main(int argc, char *argv[]) {
     bool ignore_vertex_types = false;
 
     if (ignore_vertex_types) {
-        for (const auto &vert : graph_copy.vertices()) { graph_copy.set_vertex_type(vert, 0); }
+        for (const auto &vert : graph_copy.vertices()) {
+            graph_copy.set_vertex_type(vert, 0);
+        }
     }
 
     coarser.coarsenDag(graph_copy, coarse_graph, contraction_map);
 
     std::vector<unsigned> colours(contraction_map.size());
-    for (std::size_t i = 0; i < contraction_map.size(); ++i) { colours[i] = static_cast<unsigned>(contraction_map[i]); }
+    for (std::size_t i = 0; i < contraction_map.size(); ++i) {
+        colours[i] = static_cast<unsigned>(contraction_map[i]);
+    }
 
     std::ofstream out_dot(argv[2]);
     if (!out_dot.is_open()) {

apps/graph_analyser.cpp

@@ -46,14 +46,20 @@ void add_graph_stats(const ComputationalDag &graph, std::ofstream &outfile) {
 
         edge_lengths.emplace(diff);
         sum_edge_length += diff;
-        if (diff == 1) { short_edges += 1; }
+        if (diff == 1) {
+            short_edges += 1;
+        }
     }
     unsigned median_edge_length = 0;
-    if (!edge_lengths.empty()) { median_edge_length = Get_Median(edge_lengths); }
+    if (!edge_lengths.empty()) {
+        median_edge_length = Get_Median(edge_lengths);
+    }
 
     Get_Median(edge_lengths);
 
-    if (graph.num_edges() != 0) { avg_edge_length = static_cast<float>(sum_edge_length) / static_cast<float>(graph.num_edges()); }
+    if (graph.num_edges() != 0) {
+        avg_edge_length = static_cast<float>(sum_edge_length) / static_cast<float>(graph.num_edges());
+    }
 
     // Longest Path
     unsigned longest_path = 1;
@@ -71,7 +77,9 @@ void add_graph_stats(const ComputationalDag &graph, std::ofstream &outfile) {
     // Average bottom distance
     std::vector<unsigned> bot_level = get_bottom_node_distance(graph);
     size_t bot_level_sum = 0;
-    for (size_t i = 0; i < bot_level.size(); i++) { bot_level_sum += bot_level[i]; }
+    for (size_t i = 0; i < bot_level.size(); i++) {
+        bot_level_sum += bot_level[i];
+    }
     float avg_bot_level = static_cast<float>(bot_level_sum) / static_cast<float>(bot_level.size());
 
     // // Number of Triangles
@@ -143,7 +151,9 @@ int main(int argc, char *argv[]) {
                        << std::endl;
 
     for (const auto &dirEntry : std::filesystem::recursive_directory_iterator(graph_dir)) {
-        if (std::filesystem::is_directory(dirEntry)) { continue; }
+        if (std::filesystem::is_directory(dirEntry)) {
+            continue;
+        }
 
         std::cout << "Processing: " << dirEntry << std::endl;
 
@@ -156,7 +166,9 @@ int main(int argc, char *argv[]) {
             return 1;
         }
 
-        if (!status) { continue; }
+        if (!status) {
+            continue;
+        }
 
         std::string graph_name = path_str.substr(path_str.rfind("/") + 1);
         graph_name = graph_name.substr(0, graph_name.rfind("."));

apps/graph_generator/gen_Erdos-Renyi_graph.cpp

@@ -40,7 +40,9 @@ int main(int argc, char *argv[]) {
     size_t num_vert = static_cast<size_t>(std::stoul(argv[1]));
     double chance = 2 * std::atof(argv[2]);
     unsigned num_graphs = 1;
-    if (argc > 3) { num_graphs = static_cast<unsigned>(std::stoul(argv[3])); }
+    if (argc > 3) {
+        num_graphs = static_cast<unsigned>(std::stoul(argv[3]));
+    }
 
     //  Initiating random values
     double lower_bound = -2;

apps/graph_generator/gen_near_diag_random_graph.cpp

@@ -41,7 +41,9 @@ int main(int argc, char *argv[]) {
     double prob = std::atof(argv[2]);
     double bandwidth = std::atof(argv[3]);
     unsigned num_graphs = 1;
-    if (argc > 4) { num_graphs = static_cast<unsigned>(std::stoul(argv[3])); }
+    if (argc > 4) {
+        num_graphs = static_cast<unsigned>(std::stoul(argv[3]));
+    }
 
     // std::cout << "Vert: " << num_vert << " prob: " << prob << " bandwidth: " << bandwidth << " graphs: " <<
     // num_graphs << std::endl;

apps/ilp_hypergraph_partitioner.cpp

@@ -85,7 +85,9 @@ int main(int argc, char *argv[]) {
     if (file_ending == "hdag") {
         graph dag;
         file_status = file_reader::readComputationalDagHyperdagFormatDB(filename_hgraph, dag);
-        if (file_status) { instance.getHypergraph() = convert_from_cdag_as_hyperdag<hypergraph, graph>(dag); }
+        if (file_status) {
+            instance.getHypergraph() = convert_from_cdag_as_hyperdag<hypergraph, graph>(dag);
+        }
     } else if (file_ending == "mtx") {
         file_status = file_reader::readHypergraphMartixMarketFormat(filename_hgraph, instance.getHypergraph());
     } else {
@@ -105,8 +107,12 @@ int main(int argc, char *argv[]) {
     for (size_t node = 0; node < instance.getHypergraph().num_vertices(); ++node) {
         initial_partition.setAssignedPartition(node, static_cast<unsigned>(node % static_cast<size_t>(nr_parts)));
     }
-    if (nr_parts == 2) { fm.ImprovePartitioning(initial_partition); }
-    if (nr_parts == 4 || nr_parts == 8 || nr_parts == 16 || nr_parts == 32) { fm.RecursiveFM(initial_partition); }
+    if (nr_parts == 2) {
+        fm.ImprovePartitioning(initial_partition);
+    }
+    if (nr_parts == 4 || nr_parts == 8 || nr_parts == 16 || nr_parts == 32) {
+        fm.RecursiveFM(initial_partition);
+    }
 
     if (replicate > 0) {
         PartitioningWithReplication<hypergraph> partition(instance);
@@ -115,7 +121,9 @@ int main(int argc, char *argv[]) {
         for (size_t node = 0; node < instance.getHypergraph().num_vertices(); ++node) {
             partition.setAssignedPartitions(node, {initial_partition.assignedPartition(node)});
         }
-        if (partition.satisfiesBalanceConstraint()) { partitioner.setUseInitialSolution(true); }
+        if (partition.satisfiesBalanceConstraint()) {
+            partitioner.setUseInitialSolution(true);
+        }
 
         partitioner.setTimeLimitSeconds(600);
         if (replicate == 2) {
@@ -143,7 +151,9 @@ int main(int argc, char *argv[]) {
         for (size_t node = 0; node < instance.getHypergraph().num_vertices(); ++node) {
             partition.setAssignedPartition(node, initial_partition.assignedPartition(node));
         }
-        if (partition.satisfiesBalanceConstraint()) { partitioner.setUseInitialSolution(true); }
+        if (partition.satisfiesBalanceConstraint()) {
+            partitioner.setUseInitialSolution(true);
+        }
 
         partitioner.setTimeLimitSeconds(600);
 

apps/osp.cpp

@@ -182,7 +182,9 @@ int main(int argc, char *argv[]) {
 
         int tw = 1, ww = 1, cw = 1, nsw = 1, ct = 1;
         for (size_t i = 0; i < parser.scheduler.size(); i++) {
-            if (schedulers_failed[i]) { continue; }
+            if (schedulers_failed[i]) {
+                continue;
+            }
             tw = std::max(tw, 1 + int(std::log10(schedulers_costs[i])));
             ww = std::max(ww, 1 + int(std::log10(schedulers_work_costs[i])));
             cw = std::max(cw, 1 + int(std::log10(schedulers_costs[i] - schedulers_work_costs[i])));

apps/test_suite_runner/AbstractTestSuiteRunner.hpp

@@ -74,10 +74,14 @@ class AbstractTestSuiteRunner {
                 = parser.global_params.get_child("outputSchedule").get_value_optional<bool>().value_or(false);
 
             graph_dir_path = parser.global_params.get_child("graphDirectory").get_value<std::string>();
-            if (graph_dir_path.substr(0, 1) != "/") { graph_dir_path = executable_dir + graph_dir_path; }
+            if (graph_dir_path.substr(0, 1) != "/") {
+                graph_dir_path = executable_dir + graph_dir_path;
+            }
 
             machine_dir_path = parser.global_params.get_child("archDirectory").get_value<std::string>();
-            if (machine_dir_path.substr(0, 1) != "/") { machine_dir_path = executable_dir + machine_dir_path; }
+            if (machine_dir_path.substr(0, 1) != "/") {
+                machine_dir_path = executable_dir + machine_dir_path;
+            }
 
             if (write_target_object_to_file) {
                 output_target_object_dir_path = parser.global_params.get_child("scheduleDirectory").get_value<std::string>();
@@ -90,7 +94,9 @@ class AbstractTestSuiteRunner {
             }
 
             log_file_path = parser.global_params.get_child("outputLogFile").get_value<std::string>();
-            if (log_file_path.substr(0, 1) != "/") { log_file_path = executable_dir + log_file_path; }
+            if (log_file_path.substr(0, 1) != "/") {
+                log_file_path = executable_dir + log_file_path;
+            }
 
             statistics_output_file_path = parser.global_params.get_child("outputStatsFile").get_value<std::string>();
             if (statistics_output_file_path.substr(0, 1) != "/") {
@@ -106,7 +112,9 @@ class AbstractTestSuiteRunner {
 
     virtual void setup_log_file() {
         log_stream.open(log_file_path, std::ios_base::app);
-        if (!log_stream.is_open()) { std::cerr << "Error: Could not open log file: " << log_file_path << std::endl; }
+        if (!log_stream.is_open()) {
+            std::cerr << "Error: Could not open log file: " << log_file_path << std::endl;
+        }
     }
 
     virtual void setup_statistics_file() {
@@ -140,7 +148,9 @@ class AbstractTestSuiteRunner {
             for (size_t i = 0; i < all_csv_headers.size(); ++i) {
                 expected_header_line += all_csv_headers[i] + (i == all_csv_headers.size() - 1 ? "" : ",");
             }
-            if (first_line_in_file == expected_header_line) { file_exists_and_has_header = true; }
+            if (first_line_in_file == expected_header_line) {
+                file_exists_and_has_header = true;
+            }
             stats_file_check.close();
         }
 
@@ -172,8 +182,12 @@ class AbstractTestSuiteRunner {
     AbstractTestSuiteRunner() {}
 
     virtual ~AbstractTestSuiteRunner() {
-        if (log_stream.is_open()) { log_stream.close(); }
-        if (stats_out_stream.is_open()) { stats_out_stream.close(); }
+        if (log_stream.is_open()) {
+            log_stream.close();
+        }
+        if (stats_out_stream.is_open()) {
+            stats_out_stream.close();
+        }
     }
 
     int run(int argc, char *argv[]) {
@@ -184,7 +198,9 @@ class AbstractTestSuiteRunner {
             return 1;
         }
 
-        if (!parse_common_config()) { return 1; }
+        if (!parse_common_config()) {
+            return 1;
+        }
 
         setup_log_file();
 
@@ -202,7 +218,9 @@ class AbstractTestSuiteRunner {
             create_and_register_statistic_modules(module_name);
         }
 
-        if (active_stats_modules.empty()) { log_stream << "No active statistic modules configured or loaded." << std::endl; }
+        if (active_stats_modules.empty()) {
+            log_stream << "No active statistic modules configured or loaded." << std::endl;
+        }
 
         setup_statistics_file();
 
@@ -213,7 +231,9 @@ class AbstractTestSuiteRunner {
             }
             std::string filename_machine = machine_entry.path().string();
             std::string name_machine = filename_machine.substr(filename_machine.rfind('/') + 1);
-            if (name_machine.rfind('.') != std::string::npos) { name_machine = name_machine.substr(0, name_machine.rfind('.')); }
+            if (name_machine.rfind('.') != std::string::npos) {
+                name_machine = name_machine.substr(0, name_machine.rfind('.'));
+            }
 
             BspArchitecture<GraphType> arch;
             if (!file_reader::readBspArchitecture(filename_machine, arch)) {
@@ -229,7 +249,9 @@ class AbstractTestSuiteRunner {
                 }
                 std::string filename_graph = graph_entry.path().string();
                 std::string name_graph = filename_graph.substr(filename_graph.rfind('/') + 1);
-                if (name_graph.rfind('.') != std::string::npos) { name_graph = name_graph.substr(0, name_graph.rfind('.')); }
+                if (name_graph.rfind('.') != std::string::npos) {
+                    name_graph = name_graph.substr(0, name_graph.rfind('.'));
+                }
                 log_stream << "Start Graph: " + filename_graph + "\n";
 
                 BspInstance<GraphType> bsp_instance;

apps/test_suite_runner/ConfigParser.hpp

@@ -69,7 +69,9 @@ struct ConfigParser {
         bool algorithm_found = false;
         std::string algorithm_identifier = name;
 
-        while (algorithm_identifier.find("-") == 0) { algorithm_identifier = algorithm_identifier.substr(1); }
+        while (algorithm_identifier.find("-") == 0) {
+            algorithm_identifier = algorithm_identifier.substr(1);
+        }
 
         for (auto &algorithm : scheduler_config) {
             std::string alg_name = algorithm.second.get_child("name").get_value<std::string>();
@@ -97,7 +99,9 @@ struct ConfigParser {
 
         pt::ptree scheduler_config_parse = loadPtreeRoot.get_child("algorithms");
         for (auto &algorithm : scheduler_config_parse) {
-            if (algorithm.second.get_child("run").get_value<bool>()) { scheduler.push_back(algorithm); }
+            if (algorithm.second.get_child("run").get_value<bool>()) {
+                scheduler.push_back(algorithm);
+            }
         }
     }
 

apps/test_suite_runner/StatsModules/BspSptrsvStatsModule.hpp

@@ -168,9 +168,13 @@ class BspSptrsvStatsModule : public IStatisticModule<TargetObjectType> {
             };
 
             // Permute back if needed
-            if (mode != NO_PERMUTE) { sim.permute_x_vector(perm); }
+            if (mode != NO_PERMUTE) {
+                sim.permute_x_vector(perm);
+            }
 
-            if (!compare_vectors(L_x_ref, L_x_osp)) { std::cout << "Output is not equal" << std::endl; }
+            if (!compare_vectors(L_x_ref, L_x_osp)) {
+                std::cout << "Output is not equal" << std::endl;
+            }
 
             const std::string prefix = mode_tag(mode);
             stats[prefix + "SpTrSV_Runtime_Geomean(ns)"] = to_str(geom_mean);

apps/test_suite_runner/StringToScheduler/run_bsp_recomp_scheduler.hpp

@@ -52,7 +52,9 @@ RETURN_STATUS run_bsp_recomp_scheduler(const ConfigParser &parser,
 
         BspScheduleCS<Graph_t> initial_schedule(std::move(bsp_schedule));
 
-        if (status == RETURN_STATUS::ERROR) { return RETURN_STATUS::ERROR; }
+        if (status == RETURN_STATUS::ERROR) {
+            return RETURN_STATUS::ERROR;
+        }
 
         GreedyRecomputer<Graph_t> scheduler;