Merge branch 'main' into reuse-basis-factorization

Author: nguidotti

benchmarks/linear_programming/cuopt/run_mip.cpp

@@ -22,8 +22,8 @@
 #include <cuopt/linear_programming/mip/solver_solution.hpp>
 #include <cuopt/linear_programming/optimization_problem.hpp>
 #include <cuopt/linear_programming/solve.hpp>
-#include <cuopt/logger.hpp>
 #include <mps_parser/parser.hpp>
+#include <utilities/logger.hpp>
 
 #include <raft/core/handle.hpp>
 

cpp/cuopt_cli.cpp

@@ -18,8 +18,8 @@
 #include <cuopt/linear_programming/mip/solver_settings.hpp>
 #include <cuopt/linear_programming/optimization_problem.hpp>
 #include <cuopt/linear_programming/solve.hpp>
-#include <cuopt/logger.hpp>
 #include <mps_parser/parser.hpp>
+#include <utilities/logger.hpp>
 
 #include <raft/core/handle.hpp>
 
@@ -75,6 +75,18 @@ static char cuda_module_loading_env[] = "CUDA_MODULE_LOADING=EAGER";
  */
 inline auto make_async() { return std::make_shared<rmm::mr::cuda_async_memory_resource>(); }
 
+/**
+ * @brief Handle logger when error happens before logger is initialized
+ * @param settings Solver settings
+ * @return cuopt::init_logger_t
+ */
+inline cuopt::init_logger_t dummy_logger(
+  const cuopt::linear_programming::solver_settings_t<int, double>& settings)
+{
+  return cuopt::init_logger_t(settings.get_parameter<std::string>(CUOPT_LOG_FILE),
+                              settings.get_parameter<bool>(CUOPT_LOG_TO_CONSOLE));
+}
+
 /**
  * @brief Run a single file
  * @param file_path Path to the MPS format input file containing the optimization problem
@@ -94,6 +106,7 @@ int run_single_file(const std::string& file_path,
       settings.set_parameter_from_string(key, val);
     }
   } catch (const std::exception& e) {
+    auto log = dummy_logger(settings);
     CUOPT_LOG_ERROR("Error: %s", e.what());
     return -1;
   }
@@ -113,6 +126,7 @@ int run_single_file(const std::string& file_path,
     }
   }
   if (parsing_failed) {
+    auto log = dummy_logger(settings);
     CUOPT_LOG_ERROR("Parsing MPS failed. Exiting!");
     return -1;
   }
@@ -122,7 +136,8 @@ int run_single_file(const std::string& file_path,
 
   const bool is_mip =
     (op_problem.get_problem_category() == cuopt::linear_programming::problem_category_t::MIP ||
-     op_problem.get_problem_category() == cuopt::linear_programming::problem_category_t::IP);
+     op_problem.get_problem_category() == cuopt::linear_programming::problem_category_t::IP) &&
+    !solve_relaxation;
 
   try {
     auto initial_solution =
@@ -131,23 +146,36 @@ int run_single_file(const std::string& file_path,
         : cuopt::linear_programming::solution_reader_t::get_variable_values_from_sol_file(
             initial_solution_file, mps_data_model.get_variable_names());
 
-    if (is_mip && !solve_relaxation) {
+    if (is_mip) {
       auto& mip_settings = settings.get_mip_settings();
       if (initial_solution.size() > 0) {
         mip_settings.add_initial_solution(initial_solution.data(), initial_solution.size());
       }
-      auto solution = cuopt::linear_programming::solve_mip(op_problem, mip_settings);
     } else {
       auto& lp_settings = settings.get_pdlp_settings();
       if (initial_solution.size() > 0) {
         lp_settings.set_initial_primal_solution(initial_solution.data(), initial_solution.size());
       }
-      auto solution = cuopt::linear_programming::solve_lp(op_problem, lp_settings);
+    }
+  } catch (const std::exception& e) {
+    auto log = dummy_logger(settings);
+    CUOPT_LOG_ERROR("Error: %s", e.what());
+    return -1;
+  }
+
+  try {
+    if (is_mip) {
+      auto& mip_settings = settings.get_mip_settings();
+      auto solution      = cuopt::linear_programming::solve_mip(op_problem, mip_settings);
+    } else {
+      auto& lp_settings = settings.get_pdlp_settings();
+      auto solution     = cuopt::linear_programming::solve_lp(op_problem, lp_settings);
     }
   } catch (const std::exception& e) {
     CUOPT_LOG_ERROR("Error: %s", e.what());
     return -1;
   }
+
   return 0;
 }
 

cpp/src/CMakeLists.txt

@@ -14,7 +14,7 @@
 # limitations under the License.
 
 set(UTIL_SRC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/utilities/seed_generator.cu
-                   ${CMAKE_CURRENT_SOURCE_DIR}/utilities/logger_helper.cpp
+                   ${CMAKE_CURRENT_SOURCE_DIR}/utilities/logger.cpp
                    ${CMAKE_CURRENT_SOURCE_DIR}/utilities/version_info.cpp
                    ${CMAKE_CURRENT_SOURCE_DIR}/utilities/timestamp_utils.cpp)
 

cpp/src/dual_simplex/cusparse_view.cu

@@ -138,6 +138,10 @@ cusparse_view_t<i_t, f_t>::cusparse_view_t(raft::handle_t const* handle_ptr,
     d_minus_one_(f_t(-1), handle_ptr->get_stream()),
     d_zero_(f_t(0), handle_ptr->get_stream())
 {
+  RAFT_CUBLAS_TRY(raft::linalg::detail::cublassetpointermode(
+    handle_ptr->get_cublas_handle(), CUBLAS_POINTER_MODE_DEVICE, handle_ptr->get_stream()));
+  RAFT_CUSPARSE_TRY(raft::sparse::detail::cusparsesetpointermode(
+    handle_ptr->get_cusparse_handle(), CUSPARSE_POINTER_MODE_DEVICE, handle_ptr->get_stream()));
   // TMP matrix data should already be on the GPU
   constexpr bool debug = false;
   if (debug) { printf("A hash: %zu\n", A.hash()); }

cpp/src/dual_simplex/logger.hpp

@@ -18,7 +18,7 @@
 #pragma once
 
 #ifdef CUOPT_LOG_ACTIVE_LEVEL
-#include <cuopt/logger.hpp>
+#include <utilities/logger.hpp>
 #endif
 
 #include <string>

cpp/src/linear_programming/cuopt_c.cpp

@@ -20,8 +20,8 @@
 #include <cuopt/linear_programming/optimization_problem.hpp>
 #include <cuopt/linear_programming/solve.hpp>
 #include <cuopt/linear_programming/solver_settings.hpp>
-#include <cuopt/logger.hpp>
 #include <cuopt/utilities/timestamp_utils.hpp>
+#include <utilities/logger.hpp>
 
 #include <mps_parser/parser.hpp>
 

cpp/src/linear_programming/optimization_problem.cu

@@ -16,8 +16,8 @@
  */
 
 #include <cuopt/error.hpp>
-#include <cuopt/logger.hpp>
 #include <mps_parser/writer.hpp>
+#include <utilities/logger.hpp>
 
 #include <cuopt/linear_programming/optimization_problem.hpp>
 #include <mip/mip_constants.hpp>

cpp/src/linear_programming/solve.cu

@@ -20,9 +20,9 @@
 #include <linear_programming/restart_strategy/pdlp_restart_strategy.cuh>
 #include <linear_programming/step_size_strategy/adaptive_step_size_strategy.hpp>
 #include <linear_programming/translate.hpp>
-#include <linear_programming/utilities/logger_init.hpp>
 #include <linear_programming/utilities/problem_checking.cuh>
 #include <linear_programming/utils.cuh>
+#include <utilities/logger.hpp>
 
 #include <mip/mip_constants.hpp>
 #include <mip/presolve/third_party_presolve.hpp>
@@ -672,9 +672,8 @@ optimization_problem_solution_t<i_t, f_t> run_concurrent(
   // Initialize the dual simplex structures before we run PDLP.
   // Otherwise, CUDA API calls to the problem stream may occur in both threads and throw graph
   // capture off
-  auto barrier_handle                  = raft::handle_t(*op_problem.get_handle_ptr());
   rmm::cuda_stream_view barrier_stream = rmm::cuda_stream_per_thread;
-  raft::resource::set_cuda_stream(barrier_handle, barrier_stream);
+  auto barrier_handle                  = raft::handle_t(barrier_stream);
   // Make sure allocations are done on the original stream
   problem.handle_ptr->sync_stream();
 

cpp/src/linear_programming/solver_settings.cu

@@ -18,10 +18,10 @@
 #include <cuopt/error.hpp>
 #include <cuopt/linear_programming/pdlp/pdlp_warm_start_data.hpp>
 #include <cuopt/linear_programming/pdlp/solver_settings.hpp>
-#include <cuopt/logger.hpp>
 #include <math_optimization/solution_writer.hpp>
 #include <mip/mip_constants.hpp>
 #include <mps_parser/utilities/span.hpp>
+#include <utilities/logger.hpp>
 
 #include <raft/util/cudart_utils.hpp>
 

cpp/src/linear_programming/solver_solution.cu

@@ -16,9 +16,9 @@
  */
 
 #include <cuopt/linear_programming/pdlp/solver_solution.hpp>
-#include <cuopt/logger.hpp>
 #include <math_optimization/solution_writer.hpp>
 #include <mip/mip_constants.hpp>
+#include <utilities/logger.hpp>
 
 #include <raft/common/nvtx.hpp>
 #include <raft/util/cudart_utils.hpp>