Merge branch 'add_python_model_builder' of github.com:Iroy30/NvidiaCuopt into add_python_model_builder

Author: rgsl888prabhu

cpp/CMakeLists.txt

@@ -134,6 +134,12 @@ elseif(CMAKE_CUDA_LINEINFO)
   set(CMAKE_CUDA_FLAGS_RELEASE "${CMAKE_CUDA_FLAGS_RELEASE} -lineinfo")
 endif(CMAKE_BUILD_TYPE MATCHES Debug)
 
+# Undefine NDEBUG if assert mode is on
+if(DEFINE_ASSERT)
+  message(STATUS "Undefining NDEBUG with assert mode enabled")
+  add_definitions(-UNDEBUG)
+endif()
+
 
 # ##################################################################################################
 # - find CPM based dependencies  ------------------------------------------------------------------

cpp/src/linear_programming/solve.cu

@@ -467,7 +467,7 @@ void run_dual_simplex_thread(
 
 template <typename i_t, typename f_t>
 optimization_problem_solution_t<i_t, f_t> run_concurrent(
-  optimization_problem_t<i_t, f_t>& op_problem,
+  const optimization_problem_t<i_t, f_t>& op_problem,
   detail::problem_t<i_t, f_t>& problem,
   pdlp_solver_settings_t<i_t, f_t> const& settings,
   bool is_batch_mode)
@@ -540,7 +540,7 @@ optimization_problem_solution_t<i_t, f_t> run_concurrent(
 
 template <typename i_t, typename f_t>
 optimization_problem_solution_t<i_t, f_t> solve_lp_with_method(
-  optimization_problem_t<i_t, f_t>& op_problem,
+  const optimization_problem_t<i_t, f_t>& op_problem,
   detail::problem_t<i_t, f_t>& problem,
   pdlp_solver_settings_t<i_t, f_t> const& settings,
   bool is_batch_mode)
@@ -714,6 +714,12 @@ optimization_problem_solution_t<i_t, f_t> solve_lp(
     bool problem_checking,                                                             \
     bool use_pdlp_solver_mode);                                                        \
                                                                                        \
+  template optimization_problem_solution_t<int, F_TYPE> solve_lp_with_method(          \
+    const optimization_problem_t<int, F_TYPE>& op_problem,                             \
+    detail::problem_t<int, F_TYPE>& problem,                                           \
+    pdlp_solver_settings_t<int, F_TYPE> const& settings,                               \
+    bool is_batch_mode = false);                                                       \
+                                                                                       \
   template optimization_problem_t<int, F_TYPE> mps_data_model_to_optimization_problem( \
     raft::handle_t const* handle_ptr,                                                  \
     const cuopt::mps_parser::mps_data_model_t<int, F_TYPE>& data_model);

cpp/src/linear_programming/solve.cuh

@@ -30,4 +30,11 @@ cuopt::linear_programming::optimization_problem_t<i_t, f_t> mps_data_model_to_op
   raft::handle_t const* handle_ptr,
   const cuopt::mps_parser::mps_data_model_t<i_t, f_t>& data_model);
 
+template <typename i_t, typename f_t>
+cuopt::linear_programming::optimization_problem_solution_t<i_t, f_t> solve_lp_with_method(
+  const optimization_problem_t<i_t, f_t>& op_problem,
+  detail::problem_t<i_t, f_t>& problem,
+  pdlp_solver_settings_t<i_t, f_t> const& settings,
+  bool is_batch_mode = false);
+
 }  // namespace cuopt::linear_programming

cpp/src/mip/diversity/assignment_hash_map.cu

@@ -97,7 +97,7 @@ size_t assignment_hash_map_t<i_t, f_t>::hash_solution(solution_t<i_t, f_t>& solu
   hash_solution_kernel<i_t, f_t, TPB>
     <<<(integer_assignment.size() + TPB - 1) / TPB, TPB, 0, solution.handle_ptr->get_stream()>>>(
       cuopt::make_span(integer_assignment), cuopt::make_span(reduction_buffer));
-  RAFT_CHECK_CUDA(handle_ptr->get_stream());
+  RAFT_CHECK_CUDA(solution.handle_ptr->get_stream());
   // Get the number of blocks used in the hash_solution_kernel
   int num_blocks = (integer_assignment.size() + TPB - 1) / TPB;
 

cpp/src/mip/solution/solution.cu

@@ -541,6 +541,11 @@ f_t solution_t<i_t, f_t>::compute_max_int_violation()
 template <typename i_t, typename f_t>
 f_t solution_t<i_t, f_t>::compute_max_variable_violation()
 {
+  cuopt_assert(problem_ptr->n_variables == assignment.size(), "Size mismatch");
+  cuopt_assert(problem_ptr->n_variables == problem_ptr->variable_lower_bounds.size(),
+               "Size mismatch");
+  cuopt_assert(problem_ptr->n_variables == problem_ptr->variable_upper_bounds.size(),
+               "Size mismatch");
   return thrust::transform_reduce(
     handle_ptr->get_thrust_policy(),
     thrust::make_counting_iterator(0),

cpp/src/mip/solve.cu

@@ -125,10 +125,12 @@ mip_solution_t<i_t, f_t> run_mip(detail::problem_t<i_t, f_t>& problem,
     running_mip);
 
   cuopt_func_call(auto saved_problem = scaled_problem);
-  if (settings.mip_scaling) { scaling.scale_problem(); }
-  if (settings.initial_solutions.size() > 0) {
-    for (const auto& initial_solution : settings.initial_solutions) {
-      scaling.scale_primal(*initial_solution);
+  if (settings.mip_scaling) {
+    scaling.scale_problem();
+    if (settings.initial_solutions.size() > 0) {
+      for (const auto& initial_solution : settings.initial_solutions) {
+        scaling.scale_primal(*initial_solution);
+      }
     }
   }
   // only call preprocess on scaled problem, so we can compute feasibility on the original problem

cpp/src/mip/solver.cu

@@ -23,6 +23,9 @@
 #include "local_search/rounding/simple_rounding.cuh"
 #include "solver.cuh"
 
+#include <linear_programming/pdlp.cuh>
+#include <linear_programming/solve.cuh>
+
 #include <dual_simplex/branch_and_bound.hpp>
 #include <dual_simplex/simplex_solver_settings.hpp>
 #include <dual_simplex/solve.hpp>
@@ -124,6 +127,27 @@ solution_t<i_t, f_t> mip_solver_t<i_t, f_t>::run_solver()
     return sol;
   }
 
+  // if the problem was reduced to a LP: run concurrent LP
+  if (context.problem_ptr->n_integer_vars == 0) {
+    CUOPT_LOG_INFO("Problem reduced to a LP, running concurrent LP");
+    pdlp_solver_settings_t<i_t, f_t> settings{};
+    settings.time_limit = timer_.remaining_time();
+    settings.method     = method_t::Concurrent;
+
+    auto opt_sol = solve_lp_with_method<i_t, f_t>(
+      *context.problem_ptr->original_problem_ptr, *context.problem_ptr, settings);
+
+    solution_t<i_t, f_t> sol(*context.problem_ptr);
+    sol.copy_new_assignment(host_copy(opt_sol.get_primal_solution()));
+    if (opt_sol.get_termination_status() == pdlp_termination_status_t::Optimal ||
+        opt_sol.get_termination_status() == pdlp_termination_status_t::PrimalInfeasible ||
+        opt_sol.get_termination_status() == pdlp_termination_status_t::DualInfeasible) {
+      sol.set_problem_fully_reduced();
+    }
+    context.problem_ptr->post_process_solution(sol);
+    return sol;
+  }
+
   namespace dual_simplex = cuopt::linear_programming::dual_simplex;
   std::future<dual_simplex::mip_status_t> branch_and_bound_status_future;
   dual_simplex::user_problem_t<i_t, f_t> branch_and_bound_problem;

cpp/src/utilities/macros.cuh

@@ -23,7 +23,6 @@
 // 2) medium
 // 3) heavy
 #ifdef ASSERT_MODE
-#undef NDEBUG
 #include <cassert>
 #define cuopt_assert(val, msg) assert(val&& msg)
 #define cuopt_func_call(func)  func;

cpp/tests/mip/bounds_standardization_test.cu

@@ -71,6 +71,7 @@ void test_bounds_standardization_test(std::string test_instance)
   init_handler(op_problem.get_handle_ptr());
   // run the problem constructor of MIP, so that we do bounds standardization
   detail::problem_t<int, double> standardized_problem(op_problem);
+  detail::problem_t<int, double> original_problem(op_problem);
   standardized_problem.preprocess_problem();
   detail::trivial_presolve(standardized_problem);
   detail::solution_t<int, double> solution_1(standardized_problem);
@@ -88,6 +89,7 @@ void test_bounds_standardization_test(std::string test_instance)
   // only consider the pdlp results
   EXPECT_TRUE(sol_1_feasible);
   standardized_problem.post_process_solution(solution_1);
+  solution_1.problem_ptr = &original_problem;
   auto optimization_prob_solution =
     solution_1.get_solution(sol_1_feasible, solver_stats_t<int, double>{});
   test_objective_sanity(problem,

cpp/tests/mip/elim_var_remap_test.cu

@@ -154,6 +154,7 @@ void test_elim_var_solution(std::string test_instance)
   init_handler(op_problem.get_handle_ptr());
   // run the problem constructor of MIP, so that we do bounds standardization
   detail::problem_t<int, double> standardized_problem(op_problem);
+  detail::problem_t<int, double> original_problem(op_problem);
   standardized_problem.preprocess_problem();
   trivial_presolve(standardized_problem);
   detail::problem_t<int, double> sub_problem(standardized_problem);
@@ -171,7 +172,8 @@ void test_elim_var_solution(std::string test_instance)
   bool sol_1_feasible = (int)result_1.get_termination_status() == CUOPT_TERIMINATION_STATUS_OPTIMAL;
   EXPECT_EQ((int)result_1.get_termination_status(), CUOPT_TERIMINATION_STATUS_OPTIMAL);
   standardized_problem.post_process_solution(solution_1);
-  auto opt_sol_1 = solution_1.get_solution(sol_1_feasible, solver_stats_t<int, double>{});
+  solution_1.problem_ptr = &original_problem;
+  auto opt_sol_1         = solution_1.get_solution(sol_1_feasible, solver_stats_t<int, double>{});
   test_objective_sanity(
     mps_problem, opt_sol_1.get_solution(), opt_sol_1.get_objective_value(), 1e-3);
   test_constraint_sanity_per_row(
@@ -198,7 +200,8 @@ void test_elim_var_solution(std::string test_instance)
   bool sol_2_feasible = (int)result_2.get_termination_status() == CUOPT_TERIMINATION_STATUS_OPTIMAL;
   EXPECT_EQ((int)result_2.get_termination_status(), CUOPT_TERIMINATION_STATUS_OPTIMAL);
   sub_problem.post_process_solution(solution_2);
-  auto opt_sol_2 = solution_2.get_solution(sol_2_feasible, solver_stats_t<int, double>{});
+  solution_2.problem_ptr = &original_problem;
+  auto opt_sol_2         = solution_2.get_solution(sol_2_feasible, solver_stats_t<int, double>{});
   test_objective_sanity(
     mps_problem, opt_sol_2.get_solution(), opt_sol_2.get_objective_value(), 1e-3);
   test_constraint_sanity_per_row(