Merge pull request #72 from Algebraic-Programming/types_in_arch_file_and_app

types in arch file reader + app update + fixes

Author: papp-pal-andras

apps/osp.cpp

@@ -79,8 +79,12 @@ int main(int argc, char *argv[]) {
             continue;
         }
 
-        std::cout << "Warning: assuming all node types can be scheduled on all processor types!\n";
-        bspInstance.SetAllOnesCompatibilityMatrix();
+        if (bspInstance.GetComputationalDag().NumVertexTypes() == bspInstance.GetArchitecture().GetNumberOfProcessorTypes()) {
+            bspInstance.SetDiagonalCompatibilityMatrix(bspInstance.GetComputationalDag().NumVertexTypes());
+        } else {
+            std::cout << "Warning: Mismatch in number of node & processor types - assuming full compatibility instead!\n";
+            bspInstance.SetAllOnesCompatibilityMatrix();
+        }
 
         std::vector<std::string> schedulersName(parser.scheduler_.size(), "");
         std::vector<bool> schedulersFailed(parser.scheduler_.size(), false);
@@ -93,6 +97,14 @@ int main(int argc, char *argv[]) {
         for (auto &algorithm : parser.scheduler_) {
             schedulersName[algorithmCounter] = algorithm.second.get_child("name").get_value<std::string>();
 
+            if (schedulersName[algorithmCounter].find("GrowLocal") != std::string::npos && bspInstance.HasAnyTypeRestrictions()) {
+                schedulersFailed[algorithmCounter] = true;
+                std::cerr << "Error: Algorithm" + algorithm.second.get_child("name").get_value<std::string>()
+                                + " skipped, since GrowLocal cannot handle heterogeneous problem instances." << std::endl;
+                algorithmCounter++;
+                continue;
+            }
+
             const auto startTime = std::chrono::high_resolution_clock::now();
 
             ReturnStatus returnStatus;
@@ -105,6 +117,7 @@ int main(int argc, char *argv[]) {
                 std::cerr << "Error during execution of Scheduler " + algorithm.second.get_child("name").get_value<std::string>()
                                  + "."
                           << std::endl;
+                algorithmCounter++;
                 continue;
             }
 
@@ -198,13 +211,12 @@ int main(int argc, char *argv[]) {
         std::cout << "Number of Vertices: " + std::to_string(bspInstance.GetComputationalDag().NumVertices())
                          + "  Number of Edges: " + std::to_string(bspInstance.GetComputationalDag().NumEdges())
                   << std::endl;
+        std::vector<std::string> listOfFailed;
         for (size_t j = 0; j < parser.scheduler_.size(); j++) {
-            size_t i = j;
-
-            i = ordering[j];
+            size_t i = ordering[j];
 
             if (schedulersFailed[i]) {
-                std::cout << "scheduler " << schedulersName[i] << " failed." << std::endl;
+                listOfFailed.push_back(schedulersName[i]);
             } else {
                 std::cout << "total costs:  " << std::right << std::setw(tw) << schedulersCosts[i]
                           << "     work costs:  " << std::right << std::setw(ww) << schedulersWorkCosts[i]
@@ -214,6 +226,13 @@ int main(int argc, char *argv[]) {
                           << "     scheduler:  " << schedulersName[i] << std::endl;
             }
         }
+        if (listOfFailed.size() > 0) {
+            std::cout << "The following schedulers failed: ";
+            for(unsigned i = 0; i < listOfFailed.size(); ++i) {
+                std::cout << ((i > 0) ? ", " : "") << listOfFailed[i];
+            }
+            std::cout << std::endl;
+        }
     }
 
     return 0;

apps/test_suite_runner/StringToScheduler/run_bsp_scheduler.hpp

@@ -79,9 +79,9 @@ std::unique_ptr<ImprovementScheduler<GraphT>> GetBspImproverByName(const ConfigP
     const std::string improverName = algorithm.get_child("name").get_value<std::string>();
 
     if (improverName == "kl_total_comm") {
-        return std::make_unique<KlTotalCommImproverMt<GraphT>>();
+        return std::make_unique<KlTotalCommImproverMt<GraphT>>(0);
     } else if (improverName == "kl_total_lambda_comm") {
-        return std::make_unique<KlTotalLambdaCommImproverMt<GraphT>>();
+        return std::make_unique<KlTotalLambdaCommImproverMt<GraphT>>(0);
     } else if (improverName == "hill_climb") {
         return std::make_unique<HillClimbingScheduler<GraphT>>();
     }

include/osp/auxiliary/io/arch_file_reader.hpp

@@ -89,6 +89,27 @@ bool ReadBspArchitecture(std::ifstream &infile, BspArchitecture<GraphT> &archite
         return false;
     }
 
+    // Read indicator bit of whether we have processor types
+    bool hasProcTypes;
+    if ((iss >> hasProcTypes) && hasProcTypes) {
+
+        // next line must have p non-negative integers with the processor types
+        while (std::getline(infile, line)) {
+            if (!line.empty() && line[0] != '%') {
+                break;
+            }
+        }
+        std::istringstream procTypes(line);
+        unsigned type;
+        for (unsigned proc = 0; proc < p; ++proc) {
+            if (!(procTypes >> type)) {
+                std::cerr << "Error: Failed to parse processor types in second line.\n";
+                return false;
+            }
+            architecture.SetProcessorType(proc, type);
+        }
+    }
+
     // Parse NUMA matrix (p x p entries)
     for (unsigned i = 0; i < p * p; ++i) {
         do {

include/osp/bsp/model/BspInstance.hpp

@@ -313,6 +313,20 @@ class BspInstance {
                                            std::vector<bool>(architecture_.GetNumberOfProcessorTypes(), true));
     }
 
+    /**
+     * @brief Checks if there are any incompatible nodetype-processortype pairs in the instance.
+     */
+    bool HasAnyTypeRestrictions() const {
+        for (VertexTypeTOrDefault node_type = 0; node_type < nodeProcessorCompatibility_.size(); ++node_type) {
+            for (VertexTypeTOrDefault proc_type = 0; proc_type < nodeProcessorCompatibility_[node_type].size(); ++proc_type) {
+                if(!nodeProcessorCompatibility_[node_type][proc_type]) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     /**
      * @brief Returns false if there is a node whose weight does not fit on any of its compatible processors.
      * @return True if the memory constraints are feasible, false otherwise.