moved compute_lazy_communication_costs

Author: tonibohnlein

include/osp/bsp/model/MaxBspSchedule.hpp

@@ -27,7 +27,7 @@ limitations under the License.
 #include <vector>
 
 #include "BspSchedule.hpp"
-#include "osp/bsp/model/cost/CostModelHelpers.hpp"
+#include "osp/bsp/model/cost/LazyCommunicationCost.hpp"
 #include "osp/concepts/computational_dag_concept.hpp"
 
 namespace osp {
@@ -93,7 +93,7 @@ class MaxBspSchedule : public BspSchedule<Graph_t> {
         std::vector<std::vector<v_commw_t<Graph_t>>> rec(this->instance->numberOfProcessors(), std::vector<v_commw_t<Graph_t>>(this->number_of_supersteps, 0));
         std::vector<std::vector<v_commw_t<Graph_t>>> send(this->instance->numberOfProcessors(), std::vector<v_commw_t<Graph_t>>(this->number_of_supersteps, 0));
 
-        cost_helpers::compute_lazy_communication_costs(*this, rec, send);
+        compute_lazy_communication_costs(*this, rec, send);
         const std::vector<v_commw_t<Graph_t>> max_comm_per_step = cost_helpers::compute_max_comm_per_step(*this, rec, send);
         const std::vector<v_workw_t<Graph_t>> max_work_per_step = cost_helpers::compute_max_work_per_step(*this);
 

include/osp/bsp/model/cost/CostModelHelpers.hpp

@@ -113,42 +113,5 @@ v_workw_t<Graph_t> compute_work_costs(
     return compute_work_costs(schedule.getInstance(), schedule.numberOfSupersteps(), schedule.assignedProcessors(), schedule.assignedSupersteps());
 }
 
-template<typename Graph_t>
-void compute_lazy_communication_costs(
-    const BspInstance<Graph_t> &instance,
-    unsigned number_of_supersteps,
-    const std::vector<unsigned> &node_to_processor_assignment,
-    const std::vector<unsigned> &node_to_superstep_assignment,
-    const unsigned staleness,
-    std::vector<std::vector<v_commw_t<Graph_t>>> &rec,
-    std::vector<std::vector<v_commw_t<Graph_t>>> &send) {
-    for (const auto &node : instance.vertices()) {
-
-        std::vector<unsigned> step_needed(instance.numberOfProcessors(), number_of_supersteps);
-        for (const auto &target : instance.getComputationalDag().children(node)) {
-
-            if (node_to_processor_assignment[node] != node_to_processor_assignment[target]) {
-                step_needed[node_to_processor_assignment[target]] = std::min(step_needed[node_to_processor_assignment[target]], node_to_superstep_assignment[target]);
-            }
-        }
-
-        for (unsigned proc = 0; proc < instance.numberOfProcessors(); proc++) {
-
-            if (step_needed[proc] < number_of_supersteps) {
-                send[node_to_processor_assignment[node]][step_needed[proc] - staleness] += instance.sendCosts(node_to_processor_assignment[node], proc) * instance.getComputationalDag().vertex_comm_weight(node);
-                rec[proc][step_needed[proc] - staleness] += instance.sendCosts(node_to_processor_assignment[node], proc) * instance.getComputationalDag().vertex_comm_weight(node);
-            }
-        }
-    }
-}
-
-template<typename Graph_t>
-void compute_lazy_communication_costs(
-    const BspSchedule<Graph_t> &schedule,
-    std::vector<std::vector<v_commw_t<Graph_t>>> &rec,
-    std::vector<std::vector<v_commw_t<Graph_t>>> &send) {
-    compute_lazy_communication_costs(schedule.getInstance(), schedule.numberOfSupersteps(), schedule.assignedProcessors(), schedule.assignedSupersteps(), schedule.getStaleness(), rec, send);
-}
-
 } // namespace cost_helpers
 } // namespace osp

include/osp/bsp/model/cost/LazyCommunicationCost.hpp

@@ -25,6 +25,43 @@ limitations under the License.
 
 namespace osp {
 
+template<typename Graph_t>
+void compute_lazy_communication_costs(
+    const BspInstance<Graph_t> &instance,
+    unsigned number_of_supersteps,
+    const std::vector<unsigned> &node_to_processor_assignment,
+    const std::vector<unsigned> &node_to_superstep_assignment,
+    const unsigned staleness,
+    std::vector<std::vector<v_commw_t<Graph_t>>> &rec,
+    std::vector<std::vector<v_commw_t<Graph_t>>> &send) {
+    for (const auto &node : instance.vertices()) {
+
+        std::vector<unsigned> step_needed(instance.numberOfProcessors(), number_of_supersteps);
+        for (const auto &target : instance.getComputationalDag().children(node)) {
+
+            if (node_to_processor_assignment[node] != node_to_processor_assignment[target]) {
+                step_needed[node_to_processor_assignment[target]] = std::min(step_needed[node_to_processor_assignment[target]], node_to_superstep_assignment[target]);
+            }
+        }
+
+        for (unsigned proc = 0; proc < instance.numberOfProcessors(); proc++) {
+
+            if (step_needed[proc] < number_of_supersteps) {
+                send[node_to_processor_assignment[node]][step_needed[proc] - staleness] += instance.sendCosts(node_to_processor_assignment[node], proc) * instance.getComputationalDag().vertex_comm_weight(node);
+                rec[proc][step_needed[proc] - staleness] += instance.sendCosts(node_to_processor_assignment[node], proc) * instance.getComputationalDag().vertex_comm_weight(node);
+            }
+        }
+    }
+}
+
+template<typename Graph_t>
+void compute_lazy_communication_costs(
+    const BspSchedule<Graph_t> &schedule,
+    std::vector<std::vector<v_commw_t<Graph_t>>> &rec,
+    std::vector<std::vector<v_commw_t<Graph_t>>> &send) {
+    compute_lazy_communication_costs(schedule.getInstance(), schedule.numberOfSupersteps(), schedule.assignedProcessors(), schedule.assignedSupersteps(), schedule.getStaleness(), rec, send);
+}
+
 /**
  * @struct LazyCommunicationCost
  * @brief Implements the lazy communication cost model.
@@ -41,7 +78,7 @@ struct LazyCommunicationCost {
         std::vector<std::vector<v_commw_t<Graph_t>>> rec(number_of_processors, std::vector<v_commw_t<Graph_t>>(number_of_supersteps, 0));
         std::vector<std::vector<v_commw_t<Graph_t>>> send(number_of_processors, std::vector<v_commw_t<Graph_t>>(number_of_supersteps, 0));
 
-        cost_helpers::compute_lazy_communication_costs(schedule, rec, send);
+        compute_lazy_communication_costs(schedule, rec, send);
         const auto max_comm_per_step = cost_helpers::compute_max_comm_per_step(schedule, rec, send);
 
         v_commw_t<Graph_t> comm_costs = 0;