Merge pull request #36 from Algebraic-Programming/more_ILPs_from_old_branch

Improvement ILPs for BSP scheduling, adapted from old branch:
- Comm. scheduling ILP
- Partial ILP for segment of a schedule (this has been changed somewhat, reintroduced many old optimizations that were present in the old python code, so now it's again in sync with what was written down in the SPAA paper)
 - Some helper functions on BspSchedule classes that were needed for these, and are also good in general (merge schedule supersteps, remove unneeded comm. steps)
- Merge changes based on some more warnings elevated in the meantime

Author: papp-pal-andras

include/osp/bsp/model/BspSchedule.hpp

@@ -830,6 +830,28 @@ class BspSchedule : public IBspSchedule<Graph_t>, public IBspScheduleEval<Graph_
         return num;
     }
 
+    virtual void shrinkByMergingSupersteps() {
+
+        std::vector<bool> comm_phase_empty(number_of_supersteps, true);
+        for (const auto& node : instance->vertices())
+            for (const auto &child : instance->getComputationalDag().children(node))
+                if(node_to_processor_assignment[node] != node_to_processor_assignment[child])
+                    comm_phase_empty[node_to_superstep_assignment[child]-1] = false;
+
+        std::vector<unsigned> new_step_index(number_of_supersteps);
+        unsigned current_index = 0;
+        for(unsigned step = 0; step < number_of_supersteps; ++step)
+        {
+            new_step_index[step] = current_index;
+            if(!comm_phase_empty[step])
+                current_index++;
+        }
+        for (const auto& node : instance->vertices())
+            node_to_superstep_assignment[node] = new_step_index[node_to_superstep_assignment[node]];
+
+        setNumberOfSupersteps(current_index);
+    }
+    
     unsigned virtual getStaleness() const { return 1; }
 };
 

include/osp/bsp/model/BspScheduleCS.hpp

@@ -467,6 +467,127 @@ class BspScheduleCS : public BspSchedule<Graph_t> {
             }
         }
     }
+
+    virtual void shrinkByMergingSupersteps() override {
+
+        std::vector<unsigned> comm_phase_latest_dependency(this->number_of_supersteps, 0);
+        std::vector<std::vector<unsigned> > first_at = getFirstPresence();
+
+        for (auto const &[key, val] : commSchedule)
+            if(this->assignedProcessor(std::get<0>(key)) != std::get<1>(key))
+                comm_phase_latest_dependency[val] = std::max(comm_phase_latest_dependency[val], first_at[std::get<0>(key)][std::get<1>(key)]);
+        
+
+        for (const auto &node : BspSchedule<Graph_t>::instance->getComputationalDag().vertices())
+            for (const auto &child : BspSchedule<Graph_t>::instance->getComputationalDag().children(node))
+                if(this->assignedProcessor(node) != this->assignedProcessor(child))
+                    comm_phase_latest_dependency[this->assignedSuperstep(child)] = std::max(comm_phase_latest_dependency[this->assignedSuperstep(child)], first_at[node][this->assignedProcessor(child)]);
+
+        std::vector<bool> comm_phase_deleted(this->number_of_supersteps, false);
+        for(unsigned step = this->number_of_supersteps-1; step < this->number_of_supersteps; --step)
+        {
+            unsigned limit = 0;
+            while(step > limit)
+            {
+                limit = std::max(limit, comm_phase_latest_dependency[step]);
+                if(step > limit)
+                {
+                    comm_phase_deleted[step] = true;
+                    --step;
+                }
+            }
+        }
+
+        std::vector<unsigned> new_step_index(this->number_of_supersteps);
+        unsigned current_index = std::numeric_limits<unsigned>::max();
+        for(unsigned step = 0; step < this->number_of_supersteps; ++step)
+        {
+            if(!comm_phase_deleted[step])
+                current_index++;
+
+            new_step_index[step] = current_index;
+        }
+        for (const auto& node : this->instance->vertices())
+            this->node_to_superstep_assignment[node] = new_step_index[this->node_to_superstep_assignment[node]];
+        for (auto &[key, val] : commSchedule)
+            val = new_step_index[val];
+
+        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(),
+            std::vector<unsigned>(BspSchedule<Graph_t>::instance->numberOfProcessors(), std::numeric_limits<unsigned>::max()));
+
+        for (const auto &node : BspSchedule<Graph_t>::instance->getComputationalDag().vertices())
+            first_at[node][this->assignedProcessor(node)] = this->assignedSuperstep(node);
+
+        for (auto const &[key, val] : commSchedule)
+            first_at[std::get<0>(key)][std::get<2>(key)] =
+                std::min(first_at[std::get<0>(key)][std::get<2>(key)], val + 1); // TODO: replace by staleness after merge
+
+        return first_at;
+    }
+
+    // remove unneeded comm. schedule entries - these can happen in ILPs, partial ILPs, etc.
+    void cleanCommSchedule(){
+
+        // data that is already present before it arrives
+        std::vector<std::vector<std::multiset<unsigned> > > arrives_at(BspSchedule<Graph_t>::instance->numberOfVertices(),
+            std::vector<std::multiset<unsigned> >(BspSchedule<Graph_t>::instance->numberOfProcessors()));
+        for (const auto &node : BspSchedule<Graph_t>::instance->getComputationalDag().vertices())
+            arrives_at[node][this->assignedProcessor(node)].insert(this->assignedSuperstep(node));
+
+        for (auto const &[key, val] : commSchedule)
+            arrives_at[std::get<0>(key)][std::get<2>(key)].insert(val);
+
+        std::vector<KeyTriple> toErase;
+        for (auto const &[key, val] : commSchedule)
+        {
+            auto itr = arrives_at[std::get<0>(key)][std::get<2>(key)].begin();
+            if(*itr < val)
+                toErase.push_back(key);
+            else if(*itr == val && ++itr != arrives_at[std::get<0>(key)][std::get<2>(key)].end() && *itr == val)
+            {
+                toErase.push_back(key);
+                arrives_at[std::get<0>(key)][std::get<2>(key)].erase(itr);
+            }
+        }
+
+        for(const KeyTriple& key : toErase)
+            commSchedule.erase(key);
+
+        // data that is not used after being sent
+        std::vector<std::vector<std::multiset<unsigned> > > used_at(BspSchedule<Graph_t>::instance->numberOfVertices(),
+            std::vector<std::multiset<unsigned> >(BspSchedule<Graph_t>::instance->numberOfProcessors()));
+        for (const auto &node : BspSchedule<Graph_t>::instance->getComputationalDag().vertices())
+            for (const auto &child : BspSchedule<Graph_t>::instance->getComputationalDag().children(node))
+                used_at[node][this->assignedProcessor(child)].insert(this->assignedSuperstep(child));
+
+        for (auto const &[key, val] : commSchedule)
+            used_at[std::get<0>(key)][std::get<1>(key)].insert(val);
+        
+        // (need to visit cs entries in reverse superstep order here)
+        std::vector<std::vector<KeyTriple> > entries(this->number_of_supersteps);
+        for (auto const &[key, val] : commSchedule)
+            entries[val].push_back(key);
+
+        toErase.clear();
+        for(unsigned step = this->number_of_supersteps-1; step < this->number_of_supersteps; --step)
+            for(const KeyTriple& key : entries[step])
+                if(used_at[std::get<0>(key)][std::get<2>(key)].empty() ||
+                    *used_at[std::get<0>(key)][std::get<2>(key)].rbegin() <= step)
+                {
+                    toErase.push_back(key);
+                    auto itr =  used_at[std::get<0>(key)][std::get<1>(key)].find(step);
+                    used_at[std::get<0>(key)][std::get<1>(key)].erase(itr);
+                }
+        
+        for(const KeyTriple& key : toErase)
+            commSchedule.erase(key);
+    }
 };
 
 } // namespace osp