Batch PDLP

benchmarks/linear_programming/cuopt/benchmark_helper.hpp

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -24,8 +24,11 @@
 #include <rmm/mr/owning_wrapper.hpp>
 #include <rmm/mr/pool_memory_resource.hpp>
 
+#include <cstdlib>
 #include <filesystem>
 #include <fstream>
+#include <iostream>
+#include <map>
 #include <regex>
 #include <sstream>
 #include <stdexcept>
@@ -56,7 +59,9 @@ void parse_value(std::istringstream& iss, bool& value)
   iss >> std::boolalpha >> value;
 }
 
-void fill_pdlp_hyper_params(const std::string& pdlp_hyper_params_path)
+void fill_pdlp_hyper_params(
+  const std::string& pdlp_hyper_params_path,
+  cuopt::linear_programming::pdlp_hyper_params::pdlp_hyper_params_t& params)
 {
   if (!std::filesystem::exists(pdlp_hyper_params_path)) {
     std::cerr << "PDLP config file path is not a valid: " << pdlp_hyper_params_path << std::endl;
@@ -66,67 +71,55 @@ void fill_pdlp_hyper_params(const std::string& pdlp_hyper_params_path)
   std::string line;
 
   std::map<std::string, double*> double_settings = {
-    {"initial_step_size_scaling",
-     &cuopt::linear_programming::pdlp_hyper_params::initial_step_size_scaling},
-    {"default_alpha_pock_chambolle_rescaling",
-     &cuopt::linear_programming::pdlp_hyper_params::default_alpha_pock_chambolle_rescaling},
-    {"default_reduction_exponent",
-     &cuopt::linear_programming::pdlp_hyper_params::host_default_reduction_exponent},
-    {"default_growth_exponent",
-     &cuopt::linear_programming::pdlp_hyper_params::host_default_growth_exponent},
-    {"default_primal_weight_update_smoothing",
-     &cuopt::linear_programming::pdlp_hyper_params::host_default_primal_weight_update_smoothing},
-    {"default_sufficient_reduction_for_restart",
-     &cuopt::linear_programming::pdlp_hyper_params::host_default_sufficient_reduction_for_restart},
-    {"default_necessary_reduction_for_restart",
-     &cuopt::linear_programming::pdlp_hyper_params::host_default_necessary_reduction_for_restart},
-    {"default_artificial_restart_threshold",
-     &cuopt::linear_programming::pdlp_hyper_params::default_artificial_restart_threshold},
-    {"initial_primal_weight_c_scaling",
-     &cuopt::linear_programming::pdlp_hyper_params::initial_primal_weight_c_scaling},
-    {"initial_primal_weight_b_scaling",
-     &cuopt::linear_programming::pdlp_hyper_params::initial_primal_weight_b_scaling},
-    {"primal_importance", &cuopt::linear_programming::pdlp_hyper_params::host_primal_importance},
-    {"primal_distance_smoothing",
-     &cuopt::linear_programming::pdlp_hyper_params::host_primal_distance_smoothing},
-    {"dual_distance_smoothing",
-     &cuopt::linear_programming::pdlp_hyper_params::host_dual_distance_smoothing}};
+    {"initial_step_size_scaling", &params.initial_step_size_scaling},
+    {"default_alpha_pock_chambolle_rescaling", &params.default_alpha_pock_chambolle_rescaling},
+    {"default_reduction_exponent", &params.reduction_exponent},
+    {"default_growth_exponent", &params.growth_exponent},
+    {"default_primal_weight_update_smoothing", &params.primal_weight_update_smoothing},
+    {"default_sufficient_reduction_for_restart", &params.sufficient_reduction_for_restart},
+    {"default_necessary_reduction_for_restart", &params.necessary_reduction_for_restart},
+    {"default_artificial_restart_threshold", &params.default_artificial_restart_threshold},
+    {"initial_primal_weight_c_scaling", &params.initial_primal_weight_c_scaling},
+    {"initial_primal_weight_b_scaling", &params.initial_primal_weight_b_scaling},
+    {"primal_importance", &params.primal_importance},
+    {"primal_distance_smoothing", &params.primal_distance_smoothing},
+    {"dual_distance_smoothing", &params.dual_distance_smoothing},
+    {"reflection_coefficient", &params.reflection_coefficient},
+    {"restart_k_p", &params.restart_k_p},
+    {"restart_k_i", &params.restart_k_i},
+    {"restart_k_d", &params.restart_k_d},
+    {"restart_i_smooth", &params.restart_i_smooth}};
 
   std::map<std::string, int*> int_settings = {
-    {"default_l_inf_ruiz_iterations",
-     &cuopt::linear_programming::pdlp_hyper_params::default_l_inf_ruiz_iterations},
-    {"major_iteration", &cuopt::linear_programming::pdlp_hyper_params::major_iteration},
-    {"min_iteration_restart", &cuopt::linear_programming::pdlp_hyper_params::min_iteration_restart},
-    {"restart_strategy", &cuopt::linear_programming::pdlp_hyper_params::restart_strategy},
+    {"default_l_inf_ruiz_iterations", &params.default_l_inf_ruiz_iterations},
+    {"major_iteration", &params.major_iteration},
+    {"min_iteration_restart", &params.min_iteration_restart},
+    {"restart_strategy", &params.restart_strategy},
   };
 
   std::map<std::string, bool*> bool_settings = {
-    {"do_pock_chambolle_scaling",
-     &cuopt::linear_programming::pdlp_hyper_params::do_pock_chambolle_scaling},
-    {"do_ruiz_scaling", &cuopt::linear_programming::pdlp_hyper_params::do_ruiz_scaling},
-    {"compute_initial_step_size_before_scaling",
-     &cuopt::linear_programming::pdlp_hyper_params::compute_initial_step_size_before_scaling},
+    {"do_pock_chambolle_scaling", &params.do_pock_chambolle_scaling},
+    {"do_ruiz_scaling", &params.do_ruiz_scaling},
+    {"compute_initial_step_size_before_scaling", &params.compute_initial_step_size_before_scaling},
     {"compute_initial_primal_weight_before_scaling",
-     &cuopt::linear_programming::pdlp_hyper_params::compute_initial_primal_weight_before_scaling},
-    {"never_restart_to_average",
-     &cuopt::linear_programming::pdlp_hyper_params::never_restart_to_average},
+     &params.compute_initial_primal_weight_before_scaling},
+    {"never_restart_to_average", &params.never_restart_to_average},
     {"compute_last_restart_before_new_primal_weight",
-     &cuopt::linear_programming::pdlp_hyper_params::compute_last_restart_before_new_primal_weight},
-    {"artificial_restart_in_main_loop",
-     &cuopt::linear_programming::pdlp_hyper_params::artificial_restart_in_main_loop},
-    {"rescale_for_restart", &cuopt::linear_programming::pdlp_hyper_params::rescale_for_restart},
-    {"update_primal_weight_on_initial_solution",
-     &cuopt::linear_programming::pdlp_hyper_params::update_primal_weight_on_initial_solution},
-    {"update_step_size_on_initial_solution",
-     &cuopt::linear_programming::pdlp_hyper_params::update_step_size_on_initial_solution},
+     &params.compute_last_restart_before_new_primal_weight},
+    {"artificial_restart_in_main_loop", &params.artificial_restart_in_main_loop},
+    {"rescale_for_restart", &params.rescale_for_restart},
+    {"update_primal_weight_on_initial_solution", &params.update_primal_weight_on_initial_solution},
+    {"update_step_size_on_initial_solution", &params.update_step_size_on_initial_solution},
     {"handle_some_primal_gradients_on_finite_bounds_as_residuals",
-     &cuopt::linear_programming::pdlp_hyper_params::
-       handle_some_primal_gradients_on_finite_bounds_as_residuals},
-    {"project_initial_primal",
-     &cuopt::linear_programming::pdlp_hyper_params::project_initial_primal},
-    {"use_adaptive_step_size_strategy",
-     &cuopt::linear_programming::pdlp_hyper_params::use_adaptive_step_size_strategy},
-  };
+     &params.handle_some_primal_gradients_on_finite_bounds_as_residuals},
+    {"project_initial_primal", &params.project_initial_primal},
+    {"use_adaptive_step_size_strategy", &params.use_adaptive_step_size_strategy},
+    {"initial_step_size_max_singular_value", &params.initial_step_size_max_singular_value},
+    {"initial_primal_weight_combined_bounds", &params.initial_primal_weight_combined_bounds},
+    {"bound_objective_rescaling", &params.bound_objective_rescaling},
+    {"use_reflected_primal_dual", &params.use_reflected_primal_dual},
+    {"use_fixed_point_error", &params.use_fixed_point_error},
+    {"use_conditional_major", &params.use_conditional_major}};
 
   while (std::getline(file, line)) {
     std::istringstream iss(line);

benchmarks/linear_programming/cuopt/run_pdlp.cu

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2022-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -17,6 +17,7 @@
 
 #include <argparse/argparse.hpp>
 
+#include <cmath>
 #include <filesystem>
 #include <stdexcept>
 #include <string>
@@ -48,7 +49,7 @@ static void parse_arguments(argparse::ArgumentParser& program)
   program.add_argument("--pdlp-solver-mode")
     .help("Solver mode for PDLP. Possible values: Stable3 (default), Methodical1, Fast1")
     .default_value("Stable3")
-    .choices("Stable3", "Methodical1", "Fast1");
+    .choices("Stable3", "Stable2", "Stable1", "Methodical1", "Fast1");
 
   program.add_argument("--method")
     .help(
@@ -81,6 +82,7 @@ static void parse_arguments(argparse::ArgumentParser& program)
 static cuopt::linear_programming::pdlp_solver_mode_t string_to_pdlp_solver_mode(
   const std::string& mode)
 {
+  if (mode == "Stable1") return cuopt::linear_programming::pdlp_solver_mode_t::Stable1;
   if (mode == "Stable2")
     return cuopt::linear_programming::pdlp_solver_mode_t::Stable2;
   else if (mode == "Methodical1")
@@ -131,7 +133,7 @@ int main(int argc, char* argv[])
   bool use_pdlp_solver_mode = true;
   if (program.is_used("--pdlp-hyper-params-path")) {
     std::string pdlp_hyper_params_path = program.get<std::string>("--pdlp-hyper-params-path");
-    fill_pdlp_hyper_params(pdlp_hyper_params_path);
+    fill_pdlp_hyper_params(pdlp_hyper_params_path, settings.hyper_params);
     use_pdlp_solver_mode = false;
   }
 

cpp/include/cuopt/linear_programming/constants.h

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -20,47 +20,48 @@
 #define CUOPT_INSTANTIATE_INT64  0
 
 /* @brief LP/MIP parameter string constants */
-#define CUOPT_ABSOLUTE_DUAL_TOLERANCE     "absolute_dual_tolerance"
-#define CUOPT_RELATIVE_DUAL_TOLERANCE     "relative_dual_tolerance"
-#define CUOPT_ABSOLUTE_PRIMAL_TOLERANCE   "absolute_primal_tolerance"
-#define CUOPT_RELATIVE_PRIMAL_TOLERANCE   "relative_primal_tolerance"
-#define CUOPT_ABSOLUTE_GAP_TOLERANCE      "absolute_gap_tolerance"
-#define CUOPT_RELATIVE_GAP_TOLERANCE      "relative_gap_tolerance"
-#define CUOPT_INFEASIBILITY_DETECTION     "infeasibility_detection"
-#define CUOPT_STRICT_INFEASIBILITY        "strict_infeasibility"
-#define CUOPT_PRIMAL_INFEASIBLE_TOLERANCE "primal_infeasible_tolerance"
-#define CUOPT_DUAL_INFEASIBLE_TOLERANCE   "dual_infeasible_tolerance"
-#define CUOPT_ITERATION_LIMIT             "iteration_limit"
-#define CUOPT_TIME_LIMIT                  "time_limit"
-#define CUOPT_PDLP_SOLVER_MODE            "pdlp_solver_mode"
-#define CUOPT_METHOD                      "method"
-#define CUOPT_PER_CONSTRAINT_RESIDUAL     "per_constraint_residual"
-#define CUOPT_SAVE_BEST_PRIMAL_SO_FAR     "save_best_primal_so_far"
-#define CUOPT_FIRST_PRIMAL_FEASIBLE       "first_primal_feasible"
-#define CUOPT_LOG_FILE                    "log_file"
-#define CUOPT_LOG_TO_CONSOLE              "log_to_console"
-#define CUOPT_CROSSOVER                   "crossover"
-#define CUOPT_FOLDING                     "folding"
-#define CUOPT_AUGMENTED                   "augmented"
-#define CUOPT_DUALIZE                     "dualize"
-#define CUOPT_ORDERING                    "ordering"
-#define CUOPT_BARRIER_DUAL_INITIAL_POINT  "barrier_dual_initial_point"
-#define CUOPT_ELIMINATE_DENSE_COLUMNS     "eliminate_dense_columns"
-#define CUOPT_CUDSS_DETERMINISTIC         "cudss_deterministic"
-#define CUOPT_PRESOLVE                    "presolve"
-#define CUOPT_DUAL_POSTSOLVE              "dual_postsolve"
-#define CUOPT_MIP_ABSOLUTE_TOLERANCE      "mip_absolute_tolerance"
-#define CUOPT_MIP_RELATIVE_TOLERANCE      "mip_relative_tolerance"
-#define CUOPT_MIP_INTEGRALITY_TOLERANCE   "mip_integrality_tolerance"
-#define CUOPT_MIP_ABSOLUTE_GAP            "mip_absolute_gap"
-#define CUOPT_MIP_RELATIVE_GAP            "mip_relative_gap"
-#define CUOPT_MIP_HEURISTICS_ONLY         "mip_heuristics_only"
-#define CUOPT_MIP_SCALING                 "mip_scaling"
-#define CUOPT_MIP_PRESOLVE                "mip_presolve"
-#define CUOPT_SOLUTION_FILE               "solution_file"
-#define CUOPT_NUM_CPU_THREADS             "num_cpu_threads"
-#define CUOPT_NUM_GPUS                    "num_gpus"
-#define CUOPT_USER_PROBLEM_FILE           "user_problem_file"
+#define CUOPT_ABSOLUTE_DUAL_TOLERANCE         "absolute_dual_tolerance"
+#define CUOPT_RELATIVE_DUAL_TOLERANCE         "relative_dual_tolerance"
+#define CUOPT_ABSOLUTE_PRIMAL_TOLERANCE       "absolute_primal_tolerance"
+#define CUOPT_RELATIVE_PRIMAL_TOLERANCE       "relative_primal_tolerance"
+#define CUOPT_ABSOLUTE_GAP_TOLERANCE          "absolute_gap_tolerance"
+#define CUOPT_RELATIVE_GAP_TOLERANCE          "relative_gap_tolerance"
+#define CUOPT_INFEASIBILITY_DETECTION         "infeasibility_detection"
+#define CUOPT_STRICT_INFEASIBILITY            "strict_infeasibility"
+#define CUOPT_PRIMAL_INFEASIBLE_TOLERANCE     "primal_infeasible_tolerance"
+#define CUOPT_DUAL_INFEASIBLE_TOLERANCE       "dual_infeasible_tolerance"
+#define CUOPT_ITERATION_LIMIT                 "iteration_limit"
+#define CUOPT_TIME_LIMIT                      "time_limit"
+#define CUOPT_PDLP_SOLVER_MODE                "pdlp_solver_mode"
+#define CUOPT_METHOD                          "method"
+#define CUOPT_PER_CONSTRAINT_RESIDUAL         "per_constraint_residual"
+#define CUOPT_SAVE_BEST_PRIMAL_SO_FAR         "save_best_primal_so_far"
+#define CUOPT_FIRST_PRIMAL_FEASIBLE           "first_primal_feasible"
+#define CUOPT_LOG_FILE                        "log_file"
+#define CUOPT_LOG_TO_CONSOLE                  "log_to_console"
+#define CUOPT_CROSSOVER                       "crossover"
+#define CUOPT_FOLDING                         "folding"
+#define CUOPT_AUGMENTED                       "augmented"
+#define CUOPT_DUALIZE                         "dualize"
+#define CUOPT_ORDERING                        "ordering"
+#define CUOPT_BARRIER_DUAL_INITIAL_POINT      "barrier_dual_initial_point"
+#define CUOPT_ELIMINATE_DENSE_COLUMNS         "eliminate_dense_columns"
+#define CUOPT_CUDSS_DETERMINISTIC             "cudss_deterministic"
+#define CUOPT_PRESOLVE                        "presolve"
+#define CUOPT_DUAL_POSTSOLVE                  "dual_postsolve"
+#define CUOPT_MIP_ABSOLUTE_TOLERANCE          "mip_absolute_tolerance"
+#define CUOPT_MIP_RELATIVE_TOLERANCE          "mip_relative_tolerance"
+#define CUOPT_MIP_INTEGRALITY_TOLERANCE       "mip_integrality_tolerance"
+#define CUOPT_MIP_BATCH_PDLP_STRONG_BRANCHING "mip_batch_pdlp_strong_branching"
+#define CUOPT_MIP_ABSOLUTE_GAP                "mip_absolute_gap"
+#define CUOPT_MIP_RELATIVE_GAP                "mip_relative_gap"
+#define CUOPT_MIP_HEURISTICS_ONLY             "mip_heuristics_only"
+#define CUOPT_MIP_SCALING                     "mip_scaling"
+#define CUOPT_MIP_PRESOLVE                    "mip_presolve"
+#define CUOPT_SOLUTION_FILE                   "solution_file"
+#define CUOPT_NUM_CPU_THREADS                 "num_cpu_threads"
+#define CUOPT_NUM_GPUS                        "num_gpus"
+#define CUOPT_USER_PROBLEM_FILE               "user_problem_file"
 
 /* @brief LP/MIP termination status constants */
 #define CUOPT_TERIMINATION_STATUS_NO_TERMINATION   0

cpp/include/cuopt/linear_programming/mip/solver_settings.hpp

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -10,6 +10,7 @@
 #include <vector>
 
 #include <cuopt/linear_programming/constants.h>
+#include <cuopt/linear_programming/pdlp/pdlp_hyper_params.cuh>
 #include <cuopt/linear_programming/utilities/internals.hpp>
 
 #include <raft/core/device_span.hpp>
@@ -82,7 +83,8 @@ class mip_solver_settings_t {
   bool heuristics_only = false;
   i_t num_cpu_threads  = -1;  // -1 means use default number of threads in branch and bound
   i_t num_gpus         = 1;
-  bool log_to_console  = true;
+  i_t mip_batch_pdlp_strong_branching = 0;
+  bool log_to_console                 = true;
   std::string log_file;
   std::string sol_file;
   std::string user_problem_file;
@@ -95,6 +97,9 @@ class mip_solver_settings_t {
   // benchmarks
   benchmark_info_t* benchmark_info_ptr = nullptr;
 
+  // TODO check with Akif and Alice
+  pdlp_hyper_params::pdlp_hyper_params_t hyper_params;
+
  private:
   std::vector<internals::base_solution_callback_t*> mip_callbacks_;