Fixing bugs

Author: Christos Konstantinos Matzoros

include/osp/bsp/scheduler/GreedySchedulers/GreedyVarianceSspScheduler.hpp

@@ -166,8 +166,6 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
                             p = i;
                             found_allocation = true;
 
-                            procReady[i].erase(it);
-
                             if (procType < procTypesCompatibleWithNodeType_skip_proctype.size()) {
                                 const auto &compatibleTypes =
                                     procTypesCompatibleWithNodeType_skip_proctype[procType]
@@ -191,8 +189,6 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
                         p = i;
                         found_allocation = true;
 
-                        procReady[i].erase(it);
-
                         if (procType < procTypesCompatibleWithNodeType_skip_proctype.size()) {
                             const auto &compatibleTypes =
                                 procTypesCompatibleWithNodeType_skip_proctype[procType]
@@ -243,8 +239,6 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
                             node = it->first;
                             p = i;
 
-                            readyList.erase(it);
-
                             const auto &compatibleTypes =
                                 procTypesCompatibleWithNodeType_skip_proctype[procType]
                                     [instance.getComputationalDag().vertex_type(node)];
@@ -260,8 +254,6 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
                         node = it->first;
                         p = i;
 
-                        readyList.erase(it);
-
                         const auto &compatibleTypes =
                             procTypesCompatibleWithNodeType_skip_proctype[procType]
                                 [instance.getComputationalDag().vertex_type(node)];
@@ -270,11 +262,10 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
                             if (otherType < allReady.size())
                                 allReady[otherType].erase(std::make_pair(node, work_variance[node]));
                         }
-
+                        
                         return;
                     }
                 }
-
                 ++it;
             }
         }
@@ -364,20 +355,26 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
         return nr_nodes;
     }
 
-
     public:
 
-    RETURN_STATUS computeSspSchedule(BspSchedule<Graph_t> &schedule, unsigned stale) {
+    /**
+    * @brief Default constructor for GreedyVarianceSspScheduler.
+    */
+    GreedyVarianceSspScheduler(float max_percent_idle_processors_ = 0.2f, bool increase_parallelism_in_new_superstep_ = true)
+        : max_percent_idle_processors(max_percent_idle_processors_),
+          increase_parallelism_in_new_superstep(increase_parallelism_in_new_superstep_) {}
 
+    /**
+    * @brief Default destructor for GreedyVarianceSspScheduler.
+    */
+    virtual ~GreedyVarianceSspScheduler() = default;
+
+    RETURN_STATUS computeSspSchedule(BspSchedule<Graph_t> &schedule, unsigned stale) {
         const auto &instance = schedule.getInstance();
         const auto &G = instance.getComputationalDag();
-        const auto &N = instance.numberOfVertices();
+        const VertexType &N = instance.numberOfVertices();
         const unsigned &P = instance.numberOfProcessors();
 
-        for (auto v : G.vertices()) {
-            schedule.setAssignedProcessor(v, std::numeric_limits<unsigned>::max());
-        }
-        
         unsigned supstepIdx = 0;
 
         if constexpr (is_memory_constraint_v<MemoryConstraint_t>) {
@@ -407,10 +404,13 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
             ++nr_procs_per_type[instance.getArchitecture().processorType(proc)];
         }
 
-        std::vector<unsigned> nrPredecRemain(N);
-        for (VertexType node = 0; node < static_cast<VertexType>(N); ++node) {
+        std::vector<VertexType> nrPredecRemain(N);
+
+        for (VertexType node = 0; node < N; ++node) {
             const auto num_parents = G.in_degree(node);
-            nrPredecRemain[node] = static_cast<unsigned>(num_parents);
+
+            nrPredecRemain[node] = num_parents;
+
             if (num_parents == 0) {
                 ready[0].insert(std::make_pair(node, work_variances[node]));
                 nr_ready_stale_nodes_per_type[0][G.vertex_type(node)]++;
@@ -426,9 +426,6 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
         std::vector<unsigned> number_of_allocated_allReady_tasks_in_superstep(instance.getArchitecture().getNumberOfProcessorTypes(), 0);
         std::vector<unsigned> limit_of_number_of_allocated_allReady_tasks_in_superstep(instance.getArchitecture().getNumberOfProcessorTypes(), 0);
 
-        
-
-
         bool endSupStep = true;
         bool begin_outer_while = true;
         bool able_to_schedule_in_step = false;
@@ -478,12 +475,11 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
                 }
 
                 for (unsigned procType = 0; procType < instance.getArchitecture().getNumberOfProcessorTypes(); procType++) {
-                    unsigned equal_split = (static_cast<unsigned int>(allReady[procType].size()) + stale - 1) / stale;
+                    unsigned equal_split = (static_cast<unsigned>(allReady[procType].size()) + stale - 1) / stale;
                     unsigned at_least_for_long_step = 3 * nr_procs_per_type[procType];
-
                     limit_of_number_of_allocated_allReady_tasks_in_superstep[procType] = std::max(at_least_for_long_step, equal_split);
                 }
-
+            
                 endSupStep = false;
                 finishTimes.emplace(0, std::numeric_limits<VertexType>::max());
             }
@@ -508,8 +504,7 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
                             unsigned earliest_add = supstepIdx;
                             for (const auto& pred : G.parents(succ)) {
                                 if (schedule.assignedProcessor(pred) != proc_of_node) {
-                                    earliest_add = std::max(earliest_add,
-                                                            stale + schedule.assignedSuperstep(pred));
+                                    earliest_add = std::max(earliest_add, stale + schedule.assignedSuperstep(pred));
                                 }
                             }
 
@@ -542,6 +537,7 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
             if (!CanChooseNode(instance, allReady, procReady[supstepIdx % stale], procFree)) {
                 endSupStep = true;
             }
+
             while (CanChooseNode(instance, allReady, procReady[supstepIdx % stale], procFree)) {
                 VertexType nextNode = std::numeric_limits<VertexType>::max();
                 unsigned nextProc = P;
@@ -567,6 +563,7 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
                     nr_old_ready_nodes_per_type[G.vertex_type(nextNode)]--;
                     const unsigned nextProcType = instance.getArchitecture().processorType(nextProc);
                     number_of_allocated_allReady_tasks_in_superstep[nextProcType]++;
+                    
                     if (number_of_allocated_allReady_tasks_in_superstep[nextProcType] >= limit_of_number_of_allocated_allReady_tasks_in_superstep[nextProcType]) {
                         allReady[nextProcType].clear();
                     }
@@ -575,6 +572,7 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
                 for (size_t i = 0; i < stale; i++) {
                     ready[i].erase(std::make_pair(nextNode, work_variances[nextNode]));
                 }
+
                 old_ready.erase(std::make_pair(nextNode, work_variances[nextNode]));
 
                 schedule.setAssignedProcessor(nextNode, nextProc);
@@ -605,7 +603,7 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
             else if (++successive_empty_supersteps > 100 + stale)
                 return RETURN_STATUS::ERROR;
 
-            if (free > static_cast<decltype(free)>(P * max_percent_idle_processors) &&
+            if (free > (P * max_percent_idle_processors) &&
                 ((!increase_parallelism_in_new_superstep) ||
                 get_nr_parallelizable_nodes(
                     instance, stale, nr_old_ready_nodes_per_type,
@@ -626,10 +624,12 @@ class GreedyVarianceSspScheduler : public Scheduler<Graph_t> {
     }
 
     RETURN_STATUS computeSchedule(BspSchedule<Graph_t> &schedule) override {
+        std::cout<< "BspSchedule"<< std::endl;
         return computeSspSchedule(schedule, 1U);
     }
 
-    RETURN_STATUS computeSchedule(MaxBspSchedule<Graph_t> &schedule) {
+    RETURN_STATUS computeSchedule(MaxBspSchedule<Graph_t> &schedule) override {
+        std::cout<< "MaxBspSchedule"<< std::endl;
         return computeSspSchedule(schedule, 2U);
     }
 

include/osp/bsp/scheduler/Scheduler.hpp

@@ -22,6 +22,7 @@ limitations under the License.
 #include <iostream>
 #include "osp/bsp/model/BspInstance.hpp"
 #include "osp/bsp/model/BspSchedule.hpp"
+#include "osp/bsp/model/MaxBspSchedule.hpp"
 #include "osp/bsp/model/BspScheduleCS.hpp"
 #include "osp/concepts/computational_dag_concept.hpp"
 
@@ -93,6 +94,26 @@ class Scheduler {
      */
     virtual RETURN_STATUS computeSchedule(BspSchedule<Graph_t> &schedule) = 0;
 
+    /**
+     * @brief Compute a Max-BSP (Stale Synchronous Parallel) schedule for the given instance.
+     *
+     * This overload allows schedulers that support the Max-BSP or SSP model
+     * to implement asynchronous-like scheduling with configurable staleness.
+     * By default, this base implementation throws an exception, since not all
+     * schedulers provide Max-BSP support. Derived schedulers such as
+     * GreedyVarianceSspScheduler should override this function to perform
+     * their custom SSP scheduling logic.
+     *
+     * @param schedule Reference to a MaxBspSchedule object representing
+     *        the schedule to be computed and populated.
+     * @return A RETURN_STATUS code indicating the success or failure of the computation.
+     * @throws std::runtime_error If the scheduler does not implement Max-BSP scheduling.
+     */
+    virtual RETURN_STATUS computeSchedule(MaxBspSchedule<Graph_t> &schedule) {
+        (void)schedule;
+        throw std::runtime_error("Not implemented for this scheduler");
+    }
+
     virtual RETURN_STATUS computeScheduleCS(BspScheduleCS<Graph_t> &schedule) {
 
         auto result = computeSchedule(schedule);

tests/bsp_schedulers.cpp

@@ -149,6 +149,51 @@ void run_test_2(Scheduler<Graph_t> *test_scheduler) {
     }
 };
 
+template<typename Graph_t>
+void run_test_max_bsp(Scheduler<Graph_t>* test_scheduler) {
+    std::vector<std::string> filenames_graph = tiny_spaa_graphs();
+    std::vector<std::string> filenames_architectures = test_architectures();
+
+    // Locate project root
+    std::filesystem::path cwd = std::filesystem::current_path();
+    while ((!cwd.empty()) && (cwd.filename() != "OneStopParallel")) {
+        cwd = cwd.parent_path();
+    }
+
+    for (auto& filename_graph : filenames_graph) {
+        for (auto& filename_machine : filenames_architectures) {
+            std::string name_graph = filename_graph.substr(filename_graph.find_last_of("/\\") + 1);
+            name_graph = name_graph.substr(0, name_graph.find_last_of("."));
+            std::string name_machine = filename_machine.substr(filename_machine.find_last_of("/\\") + 1);
+            name_machine = name_machine.substr(0, name_machine.rfind("."));
+
+            std::cout << std::endl
+                      << "Scheduler (MaxBsp): " << test_scheduler->getScheduleName() << std::endl
+                      << "Graph: " << name_graph << std::endl
+                      << "Architecture: " << name_machine << std::endl;
+
+            computational_dag_edge_idx_vector_impl_def_int_t graph;
+            BspArchitecture<Graph_t> arch;
+
+            bool status_graph = file_reader::readGraph((cwd / filename_graph).string(), graph);
+            bool status_architecture =
+                file_reader::readBspArchitecture((cwd / filename_machine).string(), arch);
+
+            BOOST_REQUIRE_MESSAGE(status_graph, "Failed to read graph: " << filename_graph);
+            BOOST_REQUIRE_MESSAGE(status_architecture, "Failed to read architecture: " << filename_machine);
+
+            BspInstance<Graph_t> instance(graph, arch);
+
+            MaxBspSchedule<Graph_t> schedule(instance);
+
+            const auto result = test_scheduler->computeSchedule(schedule);
+
+            BOOST_CHECK_EQUAL(result, RETURN_STATUS::OSP_SUCCESS);
+            BOOST_CHECK(schedule.satisfiesPrecedenceConstraints());
+        }
+    }
+}
+
 BOOST_AUTO_TEST_CASE(GreedyBspScheduler_test) {
 
     GreedyBspScheduler<computational_dag_vector_impl_def_t> test;
@@ -377,20 +422,8 @@ BOOST_AUTO_TEST_CASE(GreedyVarianceSspScheduler_test_edge_idx_impl) {
 }
 
 // Tests computeSchedule(MaxBspSchedule&) → staleness = 2
-BOOST_AUTO_TEST_CASE(GreedyVarianceSspScheduler_MaxBspSchedule_integration) {
+BOOST_AUTO_TEST_CASE(GreedyVarianceSspScheduler_MaxBspSchedule_large_test) {
     using Graph_t = computational_dag_edge_idx_vector_impl_def_int_t;
-    BspInstance<Graph_t> instance;
-    instance.setNumberOfProcessors(2);
-    auto &dag = instance.getComputationalDag();
-    dag.add_vertex(5, 1, 0);
-    dag.add_vertex(3, 1, 0);
-    dag.add_edge(0, 1);
-
-    GreedyVarianceSspScheduler<Graph_t> scheduler;
-    MaxBspSchedule<Graph_t> schedule(instance);
-    const auto result = scheduler.computeSchedule(schedule);
-
-    BOOST_CHECK_EQUAL(result, RETURN_STATUS::OSP_SUCCESS);
-    BOOST_CHECK(schedule.satisfiesPrecedenceConstraints());
-    BOOST_CHECK(schedule.numberOfSupersteps() >= 2);
-}
+    GreedyVarianceSspScheduler<Graph_t> test;
+    run_test_max_bsp(&test);
+}