fix problem checking logic

Author: Kh4ster

cpp/include/cuopt/linear_programming/solve.hpp

@@ -71,7 +71,6 @@ optimization_problem_solution_t<i_t, f_t> solve_lp(
  * representation of a linear program
  * @param[in] settings  A pdlp_solver_settings_t<i_t, f_t> object with the settings for the PDLP
  * solver.
- * @param[in] problem_checking  If true, the problem is checked for consistency.
  * @param[in] use_pdlp_solver_modes  If true, the PDLP hyperparameters coming from the
  * pdlp_solver_mode are used (instead of the ones comming from a potential hyper-params file).
  * @param[in] inside_mip  If true, the problem is being solved in the context of a MIP.
@@ -81,7 +80,6 @@ template <typename i_t, typename f_t>
 optimization_problem_solution_t<i_t, f_t> solve_lp(
   detail::problem_t<i_t, f_t>& problem,
   pdlp_solver_settings_t<i_t, f_t> const& settings = pdlp_solver_settings_t<i_t, f_t>{},
-  bool problem_checking                            = true,
   bool use_pdlp_solver_mode                        = true,
   bool inside_mip                                  = false);
 

cpp/src/linear_programming/solve.cu

@@ -561,7 +561,6 @@ optimization_problem_solution_t<i_t, f_t> solve_lp_with_method(
 template <typename i_t, typename f_t>
 optimization_problem_solution_t<i_t, f_t> solve_lp(detail::problem_t<i_t, f_t>& problem,
                                                    pdlp_solver_settings_t<i_t, f_t> const& settings,
-                                                   bool problem_checking,
                                                    bool use_pdlp_solver_mode,
                                                    bool inside_mip)
 {
@@ -575,18 +574,10 @@ optimization_problem_solution_t<i_t, f_t> solve_lp(detail::problem_t<i_t, f_t>&
 
     raft::common::nvtx::range fun_scope("Running solver");
 
-    if (problem_checking) {
-      raft::common::nvtx::range fun_scope("Check problem representation");
-      // This is required as user might forget to set some fields
-      if (!inside_mip) {
-        problem_checking_t<i_t, f_t>::check_problem_representation(*problem.original_problem_ptr);
-        problem_checking_t<i_t, f_t>::check_initial_solution_representation(
-          *problem.original_problem_ptr, settings);
-      } else {
-        problem.check_problem_representation(true, true);
-        problem_checking_t<i_t, f_t>::check_initial_solution_representation(problem, settings);
-      }
-    }
+    cuopt_func_call(problem.check_problem_representation(true, inside_mip));
+    using problem_checking_t = problem_checking_t<i_t, f_t>;  // Can't use "," inside a macro
+    cuopt_func_call(problem_checking_t::check_initial_solution_representation(problem, settings));
+
     CUOPT_LOG_INFO(
       "Solving a problem with %d constraints %d variables (%d integers) and %d nonzeros",
       problem.n_constraints,
@@ -632,8 +623,24 @@ optimization_problem_solution_t<i_t, f_t> solve_lp(optimization_problem_t<i_t, f
                                                    bool problem_checking,
                                                    bool use_pdlp_solver_mode)
 {
-  detail::problem_t<i_t, f_t> problem(op_problem);
-  return solve_lp(problem, settings, problem_checking, use_pdlp_solver_mode);
+  try {
+    if (problem_checking) {
+      raft::common::nvtx::range fun_scope("Check problem representation");
+      problem_checking_t<i_t, f_t>::check_problem_representation(op_problem);
+      problem_checking_t<i_t, f_t>::check_initial_solution_representation(op_problem, settings);
+    }
+    detail::problem_t<i_t, f_t> problem(op_problem);
+    const bool inside_mip = false;
+    return solve_lp(problem, settings, use_pdlp_solver_mode, inside_mip);
+  } catch (const cuopt::logic_error& e) {
+    CUOPT_LOG_ERROR("Error in solve_lp: %s", e.what());
+    return optimization_problem_solution_t<i_t, f_t>{e, op_problem.get_handle_ptr()->get_stream()};
+  } catch (const std::bad_alloc& e) {
+    CUOPT_LOG_ERROR("Error in solve_lp: %s", e.what());
+    return optimization_problem_solution_t<i_t, f_t>{
+      cuopt::logic_error("Memory allocation failed", cuopt::error_type_t::RuntimeError),
+      op_problem.get_handle_ptr()->get_stream()};
+  }
 }
 
 template <typename i_t, typename f_t>
@@ -727,7 +734,6 @@ optimization_problem_solution_t<i_t, f_t> solve_lp(
   template optimization_problem_solution_t<int, F_TYPE> solve_lp(                      \
     detail::problem_t<int, F_TYPE>& problem,                                           \
     pdlp_solver_settings_t<int, F_TYPE> const& settings,                               \
-    bool problem_checking,                                                             \
     bool use_pdlp_solver_mode,                                                         \
     bool inside_mip);                                                                  \
   template optimization_problem_solution_t<int, F_TYPE> solve_lp(                      \

cpp/src/mip/relaxed_lp/relaxed_lp.cu

@@ -106,16 +106,10 @@ optimization_problem_solution_t<i_t, f_t> get_relaxed_lp_solution(
   // before LP flush the logs as it takes quite some time
   cuopt::default_logger().flush();
   // Check the problem only when in assert or debug mode
-#ifdef ASSERT_MODE
-  const bool problem_checking = true;
-#else
-  const bool problem_checking = false;
-#endif
   const bool use_pdlp_solver_mode = true;
   const bool inside_mip           = true;
 
-  auto solver_response =
-    solve_lp(op_problem, settings, problem_checking, use_pdlp_solver_mode, inside_mip);
+  auto solver_response = solve_lp(op_problem, settings, use_pdlp_solver_mode, inside_mip);
 
   if (solver_response.get_primal_solution().size() != 0 &&
       solver_response.get_dual_solution().size() != 0 && save_state) {

python/cuopt/cuopt/tests/linear_programming/test_lp_solver.py

@@ -324,7 +324,7 @@ def test_check_data_model_validity():
 
     data_model_obj = data_model.DataModel()
 
-    # Test if exception is thrown when A_CSR is not set
+    # Test if error is returned when A_CSR is not set
     solution = solver.Solve(data_model_obj)
     assert solution.get_error_status() == ErrorStatus.ValidationError
 
@@ -334,15 +334,15 @@ def test_check_data_model_validity():
     A_offsets = np.array([0, 1], dtype=np.int32)
     data_model_obj.set_csr_constraint_matrix(A_values, A_indices, A_offsets)
 
-    # Test if exception is thrown when b is not set
+    # Test if error is returned when b is not set
     solution = solver.Solve(data_model_obj)
     assert solution.get_error_status() == ErrorStatus.ValidationError
 
     # Set b with np.array
     b = np.array([1.0], dtype=np.float64)
     data_model_obj.set_constraint_bounds(b)
 
-    # Test if exception is thrown when c is not set
+    # Test if error is returned when c is not set
     solution = solver.Solve(data_model_obj)
     assert solution.get_error_status() == ErrorStatus.ValidationError
 
@@ -353,22 +353,22 @@ def test_check_data_model_validity():
     # Set maximize
     data_model_obj.set_maximize(True)
 
-    # Test if exception is thrown when maximize is set to true
+    # Test if error is returned when maximize is set to true
     solution = solver.Solve(data_model_obj)
     assert solution.get_error_status() == ErrorStatus.ValidationError
 
     # Set maximize to correct value
     data_model_obj.set_maximize(False)
 
-    # Test if exception is thrown when row_type is not set
+    # Test if error is returned when row_type is not set
     solution = solver.Solve(data_model_obj)
     assert solution.get_error_status() == ErrorStatus.ValidationError
 
     # Set row_type with np.array
     row_type = np.array(["E"])
     data_model_obj.set_row_types(row_type)
 
-    # Test if no exception is thrown when row_type is set
+    # Test if no error is returned when row_type is set
     solver.Solve(data_model_obj)
 
     # Set constraint_lower_bounds with np.array
@@ -379,7 +379,7 @@ def test_check_data_model_validity():
     constraint_upper_bounds = np.array([1.0], dtype=np.float64)
     data_model_obj.set_constraint_upper_bounds(constraint_upper_bounds)
 
-    # Test if no exception is thrown when upper constraints bounds are not set
+    # Test if no error is returned when upper constraints bounds are not set
     solver.Solve(data_model_obj)