Sarkar simple buffer merges (#28)

* homogeneous buffer merges

* Added Buffer merge modes

* small fix

* simple in and out buffer merges

* update multilevel Sarkar

* Added reverse Fan Buffer to Full Buffer logic

Author: raphael-s-steiner

apps/coarser_plotter.cpp

@@ -51,7 +51,9 @@ int main(int argc, char *argv[]) {
     params.commCostVec = std::vector<v_workw_t<Graph_t>>({1, 2, 5, 10, 20, 50, 100, 200, 500, 1000});
     params.max_num_iteration_without_changes = 3;
     params.leniency = 0.005;
-    // params.maxWeight = 15000;
+    params.maxWeight = 15000;
+    params.smallWeightThreshold = 4000;
+    params.buffer_merge_mode = SarkarParams::BufferMergeMode::FULL;
 
     SarkarMul<Graph_t, Graph_t> coarser;
     coarser.setParameters(params);

apps/test_suite_runner/StringToScheduler/get_coarser.hpp

@@ -148,7 +148,11 @@ get_coarser_by_name(const ConfigParser &, const boost::property_tree::ptree &coa
         if (auto params_opt = coarser_algorithm.get_child_optional("parameters")) {
             const auto &params_pt = params_opt.get();
             params.commCost = params_pt.get_optional<v_workw_t<Graph_t_in>>("commCost").value_or(params.commCost);
+            params.maxWeight = params_pt.get_optional<v_workw_t<Graph_t_in>>("maxWeight").value_or(params.maxWeight);
+            params.smallWeightThreshold = params_pt.get_optional<v_workw_t<Graph_t_in>>("smallWeightThreshold").value_or(params.smallWeightThreshold);
             params.useTopPoset = params_pt.get_optional<bool>("useTopPoset").value_or(params.useTopPoset);
+            params.geomDecay = params_pt.get_optional<double>("geomDecay").value_or(params.geomDecay);
+            params.leniency = params_pt.get_optional<double>("leniency").value_or(params.leniency);
 
             if (auto mode_str_opt = params_pt.get_optional<std::string>("mode")) {
                 const std::string &mode_str = mode_str_opt.get();
@@ -161,8 +165,9 @@ get_coarser_by_name(const ConfigParser &, const boost::property_tree::ptree &coa
                 else if (mode_str == "LEVEL_ODD") params.mode = SarkarParams::Mode::LEVEL_ODD;
                 else if (mode_str == "FAN_IN_BUFFER") params.mode = SarkarParams::Mode::FAN_IN_BUFFER;
                 else if (mode_str == "FAN_OUT_BUFFER") params.mode = SarkarParams::Mode::FAN_OUT_BUFFER;
+                else if (mode_str == "HOMOGENEOUS_BUFFER") params.mode = SarkarParams::Mode::HOMOGENEOUS_BUFFER;
                 else throw std::invalid_argument("Invalid Sarkar mode: " + mode_str
-                    + "!\nChoose from: LINES, FAN_IN_FULL, FAN_IN_PARTIAL, FAN_OUT_FULL, FAN_OUT_PARTIAL, LEVEL_EVEN, LEVEL_ODD, FAN_IN_BUFFER, FAN_OUT_BUFFER.");
+                    + "!\nChoose from: LINES, FAN_IN_FULL, FAN_IN_PARTIAL, FAN_OUT_FULL, FAN_OUT_PARTIAL, LEVEL_EVEN, LEVEL_ODD, FAN_IN_BUFFER, FAN_OUT_BUFFER, HOMOGENEOUS_BUFFER.");
             }
         }
         return std::make_unique<Sarkar<Graph_t_in, Graph_t_out>>(params);
@@ -216,11 +221,22 @@ get_multilevel_coarser_by_name(const ConfigParser &, const boost::property_tree:
             }
             ml_params.maxWeight =
                 params_pt.get_optional<v_workw_t<Graph_t_in>>("maxWeight").value_or(ml_params.maxWeight);
+            ml_params.smallWeightThreshold =
+                params_pt.get_optional<v_workw_t<Graph_t_in>>("smallWeightThreshold").value_or(ml_params.smallWeightThreshold);
             ml_params.max_num_iteration_without_changes =
                 params_pt.get_optional<unsigned>("max_num_iteration_without_changes")
                     .value_or(ml_params.max_num_iteration_without_changes);
-            ml_params.use_buffer_merge =
-                params_pt.get_optional<bool>("use_buffer_merge").value_or(ml_params.use_buffer_merge);
+
+            if (auto mode_str_opt = params_pt.get_optional<std::string>("buffer_merge_mode")) {
+                const std::string &mode_str = mode_str_opt.get();
+                if (mode_str == "OFF") ml_params.buffer_merge_mode = SarkarParams::BufferMergeMode::OFF;
+                else if (mode_str == "FAN_IN") ml_params.buffer_merge_mode = SarkarParams::BufferMergeMode::FAN_IN;
+                else if (mode_str == "FAN_OUT") ml_params.buffer_merge_mode = SarkarParams::BufferMergeMode::FAN_OUT;
+                else if (mode_str == "HOMOGENEOUS") ml_params.buffer_merge_mode = SarkarParams::BufferMergeMode::HOMOGENEOUS;
+                else if (mode_str == "FULL") ml_params.buffer_merge_mode = SarkarParams::BufferMergeMode::FULL;
+                else throw std::invalid_argument("Invalid Sarkar Buffer Merge mode: " + mode_str
+                    + "!\nChoose from: OFF, FAN_IN, FAN_OUT, HOMOGENEOUS, FULL.");
+            }
         }
 
         coarser->setParameters(ml_params);

include/osp/auxiliary/datastructures/union_find.hpp

@@ -41,6 +41,9 @@ struct union_find_object {
         : name(name_), parent_index(parent_index_), weight(weight_), memory(memory_) {
         rank = 1;
     }
+
+    union_find_object(const union_find_object &other) = default;
+    union_find_object& operator=(const union_find_object &other) = default;
 };
 
 /// @brief Class to execute a union-find algorithm
@@ -387,6 +390,9 @@ class Union_Find_Universe {
                                  const std::vector<memw_t> &memories) {
         add_object(names, weights, memories);
     }
+
+    Union_Find_Universe(const Union_Find_Universe &other) = default;
+    Union_Find_Universe& operator=(const Union_Find_Universe &other) = default;
 };
 
 template<typename Graph_t>

include/osp/auxiliary/math/divisors.hpp

@@ -0,0 +1,72 @@
+/*
+Copyright 2025 Huawei Technologies Co., Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+@author Toni Boehnlein, Christos Matzoros, Pal Andras Papp, Raphael S. Steiner
+*/
+#pragma once
+
+#include <cassert>
+#include <cmath>
+#include <limits>
+#include <type_traits>
+#include <vector>
+
+namespace osp {
+
+template<typename integral_type>
+integral_type intSqrtFloor(integral_type num) {
+    static_assert(std::is_integral_v<integral_type>);
+    assert(num > 0);
+
+    integral_type sqrt = 1;
+    integral_type numCopy = num;
+    while (numCopy >= 4) {
+        sqrt *= 2;
+        numCopy /= 4;
+    }
+    integral_type power2 = sqrt / 2;
+    while (power2 > 0) {
+        integral_type sum = sqrt + power2;
+        if (sum * sum <= num) {
+            sqrt = sum;
+        }
+        power2 /= 2;
+    }
+
+    return sqrt;
+}
+
+
+template<typename integral_type>
+std::vector<integral_type> divisorsList(integral_type num) {
+    static_assert(std::is_integral_v<integral_type>);
+    assert(num > 0);
+
+    std::vector<integral_type> divs;
+
+    integral_type ub = intSqrtFloor<integral_type>(num);
+    for (integral_type div = 1; div <= ub; ++div) {
+        if (num % div == 0) {
+            divs.emplace_back(div);
+        }
+    }
+    for (std::size_t indx = divs.back() * divs.back() == num ? divs.size() - 2U : divs.size() - 1U; indx != std::numeric_limits<std::size_t>::max(); --indx) {
+        divs.emplace_back(num / divs[indx]);
+    }
+
+    return divs;
+}
+
+} // end namespace osp