MAINT: Use exceptions to propagate errors

Author: HaoZeke

src/presolve/HPresolve.cpp

@@ -18,6 +18,7 @@
 #include <limits>
 
 #include "Highs.h"
+#include "HighsExceptions.h"
 #include "io/HighsIO.h"
 #include "lp_data/HConst.h"
 #include "lp_data/HStruct.h"
@@ -3914,7 +3915,14 @@ HPresolve::Result HPresolve::presolve(HighsPostsolveStack& postsolve_stack) {
       }
     };
 
-    HPRESOLVE_CHECKED_CALL(initialRowAndColPresolve(postsolve_stack));
+    try {
+      HPRESOLVE_CHECKED_CALL(initialRowAndColPresolve(postsolve_stack));
+    } catch (const DataStackOverflow& e) {
+      highsLogUser(options->log_options, HighsLogType::kInfo,
+                   "Problem is too large to be presolved\n");
+      // Here we re-throw the error
+      throw;
+    }
 
     HighsInt numParallelRowColCalls = 0;
 #if ENABLE_SPARSIFY_FOR_LP

src/presolve/HPresolve.h

@@ -32,6 +32,7 @@
 #include "util/HighsHash.h"
 #include "util/HighsLinearSumBounds.h"
 #include "util/HighsMatrixSlice.h"
+#include "util/HighsExceptions.h"
 
 namespace presolve {
 

src/presolve/HighsPostsolveStack.h

@@ -24,6 +24,7 @@
 #include <tuple>
 #include <vector>
 
+#include "HighsExceptions.h"
 #include "lp_data/HConst.h"
 #include "lp_data/HStruct.h"
 #include "lp_data/HighsOptions.h"
@@ -367,17 +368,23 @@ class HighsPostsolveStack {
   template <typename ColStorageFormat>
   void fixedColAtLower(HighsInt col, double fixValue, double colCost,
                        const HighsMatrixSlice<ColStorageFormat>& colVec) {
-    assert(std::isfinite(fixValue));
-    colValues.clear();
-    for (const HighsSliceNonzero& colVal : colVec)
-      colValues.emplace_back(origRowIndex[colVal.index()], colVal.value());
-
-    reductionValues.push(FixedCol{fixValue, colCost, origColIndex[col],
-                                  HighsBasisStatus::kLower});
-    reductionValues.push(colValues);
-    reductionAdded(ReductionType::kFixedCol);
+    try {
+      assert(std::isfinite(fixValue));
+      colValues.clear();
+      for (const HighsSliceNonzero& colVal : colVec)
+        colValues.emplace_back(origRowIndex[colVal.index()], colVal.value());
+
+      reductionValues.push(FixedCol{fixValue, colCost, origColIndex[col],
+                                    HighsBasisStatus::kLower});
+      reductionValues.push(colValues);
+      reductionAdded(ReductionType::kFixedCol);
+    } catch (const DataStackOverflow& e) {
+      std::cerr << "Memory allocation failed while processing fixedColAtLower: "
+                << e.what() << std::endl;
+      // Rethrow.
+      throw;
+    }
   }
-
   template <typename ColStorageFormat>
   void fixedColAtUpper(HighsInt col, double fixValue, double colCost,
                        const HighsMatrixSlice<ColStorageFormat>& colVec) {

src/util/HighsDataStack.h

@@ -18,9 +18,11 @@
 #define UTIL_HIGHS_DATA_STACK_H_
 
 #include <cstring>
+#include <string>
 #include <type_traits>
 #include <vector>
 
+#include "util/HighsExceptions.h"
 #include "util/HighsInt.h"
 
 #if __GNUG__ && __GNUC__ < 5
@@ -40,10 +42,18 @@ class HighsDataStack {
             typename std::enable_if<IS_TRIVIALLY_COPYABLE(T), int>::type = 0>
   void push(const T& r) {
     HighsInt dataSize = data.size();
-    data.resize(dataSize + sizeof(T));
+    HighsInt newSize = dataSize + sizeof(T);
+    try {
+      data.resize(newSize);
+    } catch (const std::length_error& e) {
+      throw DataStackOverflow(
+          "Failed to resize the vector. Requested new size: " +
+          std::to_string(newSize) + ". Size to add is " +
+          std::to_string(sizeof(T)) + "for "+
+          ". Current size: " + std::to_string(data.size()) + ".");
+    }
     std::memcpy(data.data() + dataSize, &r, sizeof(T));
   }
-
   template <typename T,
             typename std::enable_if<IS_TRIVIALLY_COPYABLE(T), int>::type = 0>
   void pop(T& r) {