avoiding out of bounds

Author: raphael-s-steiner

include/osp/bsp/model/BspArchitecture.hpp

@@ -523,7 +523,13 @@ class BspArchitecture {
      * @brief Returns the maximum memory bound over all processors.
      * @return The maximum memory bound.
      */
-    [[nodiscard]] VMemwT<GraphT> MaxMemoryBound() const { return *(std::max_element(memoryBound_.begin(), memoryBound_.end())); }
+    [[nodiscard]] VMemwT<GraphT> MaxMemoryBound() const {
+        if (memoryBound_.size() == 0U) {
+            return std::numeric_limits<VMemwT<GraphT>>::max();
+        } else {
+            return *(std::max_element(memoryBound_.begin(), memoryBound_.end()));
+        }
+    }
 
     /**
      * @brief Returns the maximum memory bound over all processors of a specific type.

include/osp/coarser/Sarkar/Sarkar.hpp

@@ -125,7 +125,7 @@ template <typename GraphTIn, typename GraphTOut>
 std::vector<VertexIdxT<GraphTIn>> Sarkar<GraphTIn, GraphTOut>::GetBotPosetMap(const GraphTIn &graph) const {
     std::vector<VertexIdxT<GraphTIn>> botPosetMap = GetBottomNodeDistance<GraphTIn, VertexIdxT<GraphTIn>>(graph);
 
-    VertexIdxT<GraphTIn> max = *std::max_element(botPosetMap.begin(), botPosetMap.end());
+    VertexIdxT<GraphTIn> max = botPosetMap.size() == 0U? 0 : *std::max_element(botPosetMap.begin(), botPosetMap.end());
     ++max;
 
     for (std::size_t i = 0; i < botPosetMap.size(); i++) {
@@ -1064,8 +1064,8 @@ VertexIdxT<GraphTIn> Sarkar<GraphTIn, GraphTOut>::LevelContraction(
     };
     std::set<std::pair<long, std::vector<VertexType>>, decltype(cmp)> vertPriority(cmp);
 
-    const VertexIdxT<GraphTIn> minLevel = *std::min_element(vertexPoset.cbegin(), vertexPoset.cend());
-    const VertexIdxT<GraphTIn> maxLevel = *std::max_element(vertexPoset.cbegin(), vertexPoset.cend());
+    const VertexIdxT<GraphTIn> minLevel = vertexPoset.size() == 0U? 0 : *std::min_element(vertexPoset.cbegin(), vertexPoset.cend());
+    const VertexIdxT<GraphTIn> maxLevel = vertexPoset.size() == 0U? 0 : *std::max_element(vertexPoset.cbegin(), vertexPoset.cend());
 
     const VertexIdxT<GraphTIn> parity = params_.mode_ == sarkar_params::Mode::LEVEL_EVEN ? 0 : 1;
 

include/osp/dag_divider/isomorphism_divider/IsomorphicSubgraphScheduler.hpp

@@ -257,8 +257,9 @@ class IsomorphicSubgraphScheduler {
                     const auto &typeCount = instance.GetArchitecture().GetProcessorTypeCount();
                     if (typeCount.empty()) {
                         effectiveMinProcTypeCount = 0;
+                    } else {
+                        effectiveMinProcTypeCount = *std::min_element(typeCount.begin(), typeCount.end());
                     }
-                    effectiveMinProcTypeCount = *std::min_element(typeCount.begin(), typeCount.end());
                     if constexpr (verbose_) {
                         std::cout << "Group " << groupIdx << " (size " << groupSize
                                   << "): Multi-type or untyped group. Using default min_proc_type_count: "

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

@@ -98,7 +98,7 @@ ReturnStatus PebblingPartialILP<GraphT>::ComputePebbling(PebblingSchedule<GraphT
     AcyclicDagDivider<GraphT> dagDivider;
     dagDivider.SetMinAndMaxSize({minPartitionSize_, maxPartitionSize_});
     std::vector<unsigned> assignmentToParts = dagDivider.ComputePartitioning(instance);
-    unsigned nrParts = *std::max_element(assignmentToParts.begin(), assignmentToParts.end()) + 1;
+    unsigned nrParts = assignmentToParts.size() == 0U? 0U : *std::max_element(assignmentToParts.begin(), assignmentToParts.end()) + 1;
 
     // TODO remove source nodes before this?
     GraphT contractedDag = ContractByPartition(instance, assignmentToParts);

tests/ilp_pebbling_scheduler.cpp

@@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE(TestFull) {
     BOOST_CHECK_EQUAL(ReturnStatus::OSP_SUCCESS, greedy.ComputeSchedule(bspInitial));
 
     std::vector<VMemwT<graph> > minimumMemoryRequiredVector = PebblingSchedule<graph>::MinimumMemoryRequiredPerNodeType(instance);
-    VMemwT<graph> maxRequired = *std::max_element(minimumMemoryRequiredVector.begin(), minimumMemoryRequiredVector.end());
+    VMemwT<graph> maxRequired = minimumMemoryRequiredVector.size() == 0U ? std::numeric_limits<VMemwT<graph>>::max() : *std::max_element(minimumMemoryRequiredVector.begin(), minimumMemoryRequiredVector.end());
     instance.GetArchitecture().SetMemoryBound(maxRequired);
 
     PebblingSchedule<graph> initialSol(bspInitial, PebblingSchedule<graph>::CacheEvictionStrategy::FORESIGHT);
@@ -93,7 +93,7 @@ BOOST_AUTO_TEST_CASE(TestPartial) {
     BOOST_CHECK(status);
 
     std::vector<VMemwT<graph> > minimumMemoryRequiredVector = PebblingSchedule<graph>::MinimumMemoryRequiredPerNodeType(instance);
-    VMemwT<graph> maxRequired = *std::max_element(minimumMemoryRequiredVector.begin(), minimumMemoryRequiredVector.end());
+    VMemwT<graph> maxRequired = minimumMemoryRequiredVector.size() == 0U ? std::numeric_limits<VMemwT<graph>>::max() : *std::max_element(minimumMemoryRequiredVector.begin(), minimumMemoryRequiredVector.end());
     instance.GetArchitecture().SetMemoryBound(maxRequired);
 
     PebblingPartialILP<graph> mpp;

tests/pebbling_schedule_class.cpp

@@ -95,7 +95,7 @@ void RunTest(Scheduler<GraphT> *testScheduler) {
 
             std::vector<VMemwT<GraphT> > minimumMemoryRequiredVector
                 = PebblingSchedule<GraphT>::MinimumMemoryRequiredPerNodeType(instance);
-            VMemwT<GraphT> maxRequired = *std::max_element(minimumMemoryRequiredVector.begin(), minimumMemoryRequiredVector.end());
+            VMemwT<GraphT> maxRequired = minimumMemoryRequiredVector.size() == 0U ? std::numeric_limits<VMemwT<GraphT>>::max() : *std::max_element(minimumMemoryRequiredVector.begin(), minimumMemoryRequiredVector.end());
             instance.GetArchitecture().SetMemoryBound(maxRequired);
 
             PebblingSchedule<GraphT> memSchedule1(bspSchedule, PebblingSchedule<GraphT>::CacheEvictionStrategy::LARGEST_ID);
@@ -159,7 +159,7 @@ BOOST_AUTO_TEST_CASE(TestPebblingScheduleWriter) {
     BOOST_CHECK_EQUAL(ReturnStatus::OSP_SUCCESS, result);
 
     std::vector<VMemwT<Graph> > minimumMemoryRequiredVector = PebblingSchedule<Graph>::MinimumMemoryRequiredPerNodeType(instance);
-    VMemwT<Graph> maxRequired = *std::max_element(minimumMemoryRequiredVector.begin(), minimumMemoryRequiredVector.end());
+    VMemwT<Graph> maxRequired = minimumMemoryRequiredVector.size() == 0U ? std::numeric_limits<VMemwT<Graph>>::max() - 3 : *std::max_element(minimumMemoryRequiredVector.begin(), minimumMemoryRequiredVector.end());
     instance.GetArchitecture().SetMemoryBound(maxRequired + 3);
 
     PebblingSchedule<Graph> memSchedule(bspSchedule, PebblingSchedule<Graph>::CacheEvictionStrategy::LEAST_RECENTLY_USED);