renaming and merge fixes

Author: papp-pal-andras

include/osp/bsp/model/BspSchedule.hpp

@@ -830,7 +830,7 @@ class BspSchedule : public IBspSchedule<Graph_t>, public IBspScheduleEval<Graph_
         return num;
     }
 
-    virtual void shrinkSchedule() {
+    virtual void shrinkByMergingSupersteps() {
 
         std::vector<bool> comm_phase_empty(number_of_supersteps, true);
         for (const auto& node : instance->vertices())

include/osp/bsp/model/BspScheduleCS.hpp

@@ -468,7 +468,7 @@ class BspScheduleCS : public BspSchedule<Graph_t> {
         }
     }
 
-    virtual void shrinkSchedule() override {
+    virtual void shrinkByMergingSupersteps() override {
 
         std::vector<unsigned> comm_phase_latest_dependency(this->number_of_supersteps, 0);
         std::vector<std::vector<unsigned> > first_at = getFirstPresence();
@@ -515,6 +515,7 @@ class BspScheduleCS : public BspSchedule<Graph_t> {
         this->setNumberOfSupersteps(current_index+1);
     }
 
+    // for each vertex v and processor p, find the first superstep where v is present on p by the end of the compute phase
     std::vector<std::vector<unsigned> > getFirstPresence() const {
 
         std::vector<std::vector<unsigned> > first_at(BspSchedule<Graph_t>::instance->numberOfVertices(),

include/osp/bsp/scheduler/IlpSchedulers/CoptCommScheduleOptimizer.hpp

@@ -48,7 +48,7 @@ class CoptCommScheduleOptimizer {
     VarArray max_comm_superstep_var;
     std::vector<std::vector<std::vector<VarArray>>> comm_processor_to_processor_superstep_node_var;
 
-    void setupVariablesConstraintsObjective(const BspScheduleCS<Graph_t>& schedule, Model& model, bool num_supersteps_can_change);
+    void setupVariablesConstraintsObjective(const BspScheduleCS<Graph_t>& schedule, Model& model);
 
     void setInitialSolution(BspScheduleCS<Graph_t>& schedule, Model &model);
 
@@ -59,6 +59,7 @@ class CoptCommScheduleOptimizer {
   public:
 
     using KeyTriple = std::tuple<vertex_idx_t<Graph_t>, unsigned int, unsigned int>;
+    virtual ~CoptCommScheduleOptimizer() = default;
 
     virtual RETURN_STATUS improveSchedule(BspScheduleCS<Graph_t> &schedule);
 
@@ -76,7 +77,7 @@ RETURN_STATUS CoptCommScheduleOptimizer<Graph_t>::improveSchedule(BspScheduleCS<
     Envr env;
     Model model = env.CreateModel("bsp_schedule_cs");
 
-    setupVariablesConstraintsObjective(schedule, model, true);
+    setupVariablesConstraintsObjective(schedule, model);
 
     setInitialSolution(schedule, model);
 
@@ -89,7 +90,7 @@ RETURN_STATUS CoptCommScheduleOptimizer<Graph_t>::improveSchedule(BspScheduleCS<
     {
         updateCommSchedule(schedule);
         if (canShrinkResultingSchedule(schedule.numberOfSupersteps()))
-           schedule.shrinkSchedule();
+           schedule.shrinkByMergingSupersteps();
     }
 
     if (model.GetIntAttr(COPT_INTATTR_MIPSTATUS) == COPT_MIPSTATUS_OPTIMAL) {
@@ -219,7 +220,7 @@ void CoptCommScheduleOptimizer<Graph_t>::setInitialSolution(BspScheduleCS<Graph_
 }
 
 template<typename Graph_t>
-void CoptCommScheduleOptimizer<Graph_t>::setupVariablesConstraintsObjective(const BspScheduleCS<Graph_t>& schedule, Model& model, bool num_supersteps_can_change) {
+void CoptCommScheduleOptimizer<Graph_t>::setupVariablesConstraintsObjective(const BspScheduleCS<Graph_t>& schedule, Model& model) {
 
     const unsigned &max_number_supersteps = schedule.numberOfSupersteps();
     const unsigned &num_processors = schedule.getInstance().numberOfProcessors();

include/osp/bsp/scheduler/IlpSchedulers/CoptPartialScheduler.hpp

@@ -81,6 +81,8 @@ class CoptPartialScheduler {
     virtual void setTimeLimitSeconds(unsigned int limit) { timeLimitSeconds = limit; }
     inline unsigned int getTimeLimitSeconds() const { return timeLimitSeconds; }
     virtual void setStartAndEndSuperstep(unsigned start_, unsigned end_) { start_superstep = start_; end_superstep = end_; }
+
+    virtual ~CoptPartialScheduler() = default;
 };
 
 template<typename Graph_t>
@@ -277,7 +279,7 @@ void CoptPartialScheduler<Graph_t>::updateSchedule(BspScheduleCS<Graph_t>& sched
     }
 
     schedule.cleanCommSchedule();
-    schedule.shrinkSchedule();
+    schedule.shrinkByMergingSupersteps();
 
 };
 
@@ -466,7 +468,7 @@ void CoptPartialScheduler<Graph_t>::setupVariablesConstraintsObjective(const Bsp
     }
 
     // boundary conditions at the end
-    for(const std::pair<vertex_idx_t<Graph_t>, unsigned>&  node_and_proc : node_needed_after_on_proc)
+    for(const std::pair<vertex_idx_t<Graph_t>, unsigned> node_and_proc : node_needed_after_on_proc)
     {
         Expr expr;
         for (unsigned int p_from = 0; p_from < num_processors; p_from++)
@@ -475,7 +477,7 @@ void CoptPartialScheduler<Graph_t>::setupVariablesConstraintsObjective(const Bsp
         model.AddConstr(expr >= 1);
     }
 
-    for(const std::pair<vertex_idx_t<Graph_t>, unsigned>&  source_and_proc : source_needed_after_on_proc)
+    for(const std::pair<vertex_idx_t<Graph_t>, unsigned> source_and_proc : source_needed_after_on_proc)
     {
         Expr expr = present_on_processor_superstep_source_var[source_and_proc.second][max_number_supersteps - 1][static_cast<int>(source_and_proc.first)];
         expr += comm_to_processor_superstep_source_var[source_and_proc.second][max_number_supersteps][static_cast<int>(source_and_proc.first)];

include/osp/bsp/scheduler/IlpSchedulers/TotalCommunicationScheduler.hpp

@@ -95,7 +95,7 @@ class TotalCommunicationScheduler : public Scheduler<Graph_t> {
 
                 for (unsigned processor = 0; processor < instance_ptr->numberOfProcessors(); processor++) {
 
-                    for (unsigned step = 0; step < (unsigned)(*node_to_processor_superstep_var_ptr)[0][0].Size();
+                    for (unsigned step = 0; step < static_cast<unsigned>((*node_to_processor_superstep_var_ptr)[0][0].Size());
                          step++) {
 
                         assert(size < std::numeric_limits<int>::max());
@@ -170,7 +170,7 @@ class TotalCommunicationScheduler : public Scheduler<Graph_t> {
 
                 for (unsigned processor = 0; processor < instance_ptr->numberOfProcessors(); processor++) {
 
-                    for (unsigned step = 0; step < (unsigned)(*node_to_processor_superstep_var_ptr)[0][0].Size();
+                    for (unsigned step = 0; step < static_cast<unsigned>((*node_to_processor_superstep_var_ptr)[0][0].Size());
                          step++) {
                         assert(step <= std::numeric_limits<int>::max());
                         if (GetSolution(
@@ -203,7 +203,7 @@ class TotalCommunicationScheduler : public Scheduler<Graph_t> {
 
                 for (unsigned processor = 0; processor < instance_ptr->numberOfProcessors(); processor++) {
 
-                    for (unsigned step = 0; step < (unsigned)(*node_to_processor_superstep_var_ptr)[0][0].Size();
+                    for (unsigned step = 0; step < static_cast<unsigned>((*node_to_processor_superstep_var_ptr)[0][0].Size());
                          step++) {
 
                         if (schedule.assignedProcessor(node) == processor && schedule.assignedSuperstep(node) == step) {
@@ -438,7 +438,7 @@ class TotalCommunicationScheduler : public Scheduler<Graph_t> {
                     expr += node_to_processor_superstep_var[node][processor][static_cast<int>(step)];
                 }
             }
-            model.AddConstr(expr <= (double)(instance.numberOfVertices() * instance.numberOfProcessors()) *
+            model.AddConstr(expr <= static_cast<double>(instance.numberOfVertices() * instance.numberOfProcessors()) *
                                         superstep_used_var.GetVar(static_cast<int>(step)));
         }
 
@@ -576,13 +576,13 @@ class TotalCommunicationScheduler : public Scheduler<Graph_t> {
                 assert(step <= std::numeric_limits<int>::max());
                 for (unsigned int processor = 0; processor < instance.numberOfProcessors(); processor++) {
 
-                    Expr expr;
+                    Expr expr_work;
                     for (const auto &node : instance.vertices()) {
-                        expr += instance.getComputationalDag().vertex_work_weight(node) *
+                        expr_work += instance.getComputationalDag().vertex_work_weight(node) *
                                 node_to_processor_superstep_var[node][processor][static_cast<int>(step)];
                     }
 
-                    model.AddConstr(max_work_superstep_var[static_cast<int>(step)] >= expr);
+                    model.AddConstr(max_work_superstep_var[static_cast<int>(step)] >= expr_work);
                 }
             }
 
@@ -597,7 +597,7 @@ class TotalCommunicationScheduler : public Scheduler<Graph_t> {
         Objective function
           */
 
-        double comm_cost = (double)instance.communicationCosts() / instance.numberOfProcessors();
+        double comm_cost = static_cast<double>(instance.communicationCosts()) / instance.numberOfProcessors();
         model.SetObjective(comm_cost * total_edges_cut + expr - instance.synchronisationCosts(), COPT_MINIMIZE);
     }
 

include/osp/bsp/scheduler/LocalSearch/KernighanLin/kl_base.hpp

@@ -455,7 +455,7 @@ class kl_base : public ImprovementScheduler<Graph_t>, public Ikl_cost_function {
             (*node_heap_handles[node]).to_step = node_best_step;
             (*node_heap_handles[node]).change_in_cost = node_change_in_cost;
 
-            if ((*node_heap_handles[node]).gain != node_max_gain) {
+            if ((*node_heap_handles[node]).gain >= node_max_gain) {
 
                 (*node_heap_handles[node]).gain = node_max_gain;
                 max_gain_heap.update(node_heap_handles[node]);
@@ -642,7 +642,7 @@ class kl_base : public ImprovementScheduler<Graph_t>, public Ikl_cost_function {
         unsigned count = 0;
         for (auto iter = max_gain_heap.ordered_begin(); iter != max_gain_heap.ordered_end(); ++iter) {
 
-            if (iter->gain == max_gain_heap.top().gain && count < local_max) {
+            if (iter->gain >= max_gain_heap.top().gain && count < local_max) {
                 max_nodes[count] = (iter->node);
                 count++;
 
@@ -1146,7 +1146,7 @@ class kl_base : public ImprovementScheduler<Graph_t>, public Ikl_cost_function {
                 compute_node_gain(node);
                 moves.push_back(best_move_change_superstep(node));
 
-                if (moves.back().gain == std::numeric_limits<double>::lowest()) {
+                if (moves.back().gain <= std::numeric_limits<double>::lowest()) {
                     abort = true;
                     break;
                 }

include/osp/pebbling/pebblers/pebblingILP/PebblingPartialILP.hpp

@@ -113,7 +113,7 @@ RETURN_STATUS PebblingPartialILP<Graph_t>::computePebbling(PebblingSchedule<Grap
     // AUX: check for isomorphism
 
     // create set of nodes & external sources for all parts, and the nodes that need to have blue pebble at the end
-    std::vector<std::set<vertex_idx> > nodes_in_part(nr_parts), extra_sources(nr_parts), needs_blue_at_end(nr_parts);
+    std::vector<std::set<vertex_idx> > nodes_in_part(nr_parts), extra_sources(nr_parts);
     std::vector<std::map<vertex_idx, vertex_idx> > original_node_id(nr_parts);
     std::vector<std::map<unsigned, unsigned> > original_proc_id(nr_parts);
     for(vertex_idx node = 0; node < instance.numberOfVertices(); ++node)
@@ -125,13 +125,6 @@ RETURN_STATUS PebblingPartialILP<Graph_t>::computePebbling(PebblingSchedule<Grap
         for (const vertex_idx &pred : instance.getComputationalDag().parents(node))
             if(assignment_to_parts[node] != assignment_to_parts[pred])
                 extra_sources[assignment_to_parts[node]].insert(pred);
-
-        for (const vertex_idx &succ : instance.getComputationalDag().children(node))
-            if(assignment_to_parts[node] != assignment_to_parts[succ])
-                needs_blue_at_end[assignment_to_parts[node]].insert(node);
-        
-        if(instance.getComputationalDag().out_degree(node) == 0)
-            needs_blue_at_end[assignment_to_parts[node]].insert(node);
     }
 
     std::vector<Graph_t> subDags;

include/osp/pebbling/pebblers/pebblingILP/partialILP/AcyclicDagDivider.hpp

@@ -34,8 +34,6 @@ class AcyclicDagDivider {
   protected:
     using vertex_idx = vertex_idx_t<Graph_t>;
 
-    std::vector<unsigned> node_to_part;
-
     unsigned minPartitionSize = 40, maxPartitionSize = 80;
     bool ignore_sources_in_size = true;
 

include/osp/pebbling/pebblers/pebblingILP/partialILP/SubproblemMultiScheduling.hpp

@@ -183,7 +183,7 @@ RETURN_STATUS SubproblemMultiScheduling<Graph_t>::computeMultiSchedule(const Bsp
 
                 ++itr_latest;
             }
-            std::vector<std::pair<vertex_idx, unsigned> > new_assingments = makeAssignment(instance, possible_nodes, free_procs);
+            new_assingments = makeAssignment(instance, possible_nodes, free_procs);
             for(auto entry : new_assingments)
             {
                 vertex_idx node = entry.first;