Remove less effective parameters

Signed-off-by: yuwenchen95 <yuwchen@nvidia.com>

Author: yuwenchen95

cpp/include/cuopt/mathematical_optimization/constants.h

@@ -54,9 +54,6 @@
 #define CUOPT_ELIMINATE_DENSE_COLUMNS              "eliminate_dense_columns"
 #define CUOPT_CUDSS_DETERMINISTIC                  "cudss_deterministic"
 #define CUOPT_CUDSS_ND_NLEVELS                     "cudss_nd_nlevels"
-#define CUOPT_CUDSS_HYBRID_MODE                    "cudss_hybrid_mode"
-#define CUOPT_CUDSS_HYBRID_EXECUTE_MODE            "cudss_hybrid_execute_mode"
-#define CUOPT_CUDSS_HOST_NTHREADS                  "cudss_host_nthreads"
 #define CUOPT_PRESOLVE                             "presolve"
 #define CUOPT_MIP_PROBING                          "mip_probing"
 #define CUOPT_DUAL_POSTSOLVE                       "dual_postsolve"

cpp/include/cuopt/mathematical_optimization/pdlp/solver_settings.hpp

@@ -291,9 +291,6 @@ class pdlp_solver_settings_t {
   bool crossover{false};
   bool cudss_deterministic{false};
   i_t cudss_nd_nlevels{-1};
-  bool cudss_hybrid_mode{false};
-  bool cudss_hybrid_execute_mode{false};
-  i_t cudss_host_nthreads{-1};
   i_t folding{-1};
   i_t augmented{-1};
   i_t dualize{-1};

cpp/src/barrier/sparse_cholesky.cuh

@@ -306,33 +306,6 @@ class sparse_cholesky_cudss_t : public sparse_cholesky_base_t<i_t, f_t> {
         "cudssConfigSet for nd nlevels");
     }
 
-    if (settings_.cudss_hybrid_mode) {
-      settings_.log.printf("cuDSS hybrid mode           : enabled\n");
-      int32_t hybrid_mode = 1;
-      CUDSS_CALL_AND_CHECK_EXIT(
-        cudssConfigSet(solverConfig, CUDSS_CONFIG_HYBRID_MODE, &hybrid_mode, sizeof(int32_t)),
-        status,
-        "cudssConfigSet for hybrid mode");
-    }
-
-    if (settings_.cudss_hybrid_execute_mode) {
-      settings_.log.printf("cuDSS hybrid execute mode    : enabled\n");
-      int32_t hybrid_execute_mode = 1;
-      CUDSS_CALL_AND_CHECK_EXIT(
-        cudssConfigSet(
-          solverConfig, CUDSS_CONFIG_HYBRID_EXECUTE_MODE, &hybrid_execute_mode, sizeof(int32_t)),
-        status,
-        "cudssConfigSet for hybrid execute mode");
-    }
-
-    if (settings_.cudss_host_nthreads >= 0) {
-      settings_.log.printf("cuDSS host nthreads         : %d\n", settings_.cudss_host_nthreads);
-      int32_t host_nthreads = settings_.cudss_host_nthreads;
-      CUDSS_CALL_AND_CHECK_EXIT(
-        cudssConfigSet(solverConfig, CUDSS_CONFIG_HOST_NTHREADS, &host_nthreads, sizeof(int32_t)),
-        status,
-        "cudssConfigSet for host nthreads");
-    }
 #endif
 
 #if USE_ITERATIVE_REFINEMENT

cpp/src/dual_simplex/simplex_solver_settings.hpp

@@ -67,9 +67,6 @@ struct simplex_solver_settings_t {
       barrier_presolve(false),
       cudss_deterministic(false),
       cudss_nd_nlevels(-1),
-      cudss_hybrid_mode(false),
-      cudss_hybrid_execute_mode(false),
-      cudss_host_nthreads(-1),
       deterministic(false),
       barrier(false),
       eliminate_dense_columns(true),
@@ -166,12 +163,7 @@ struct simplex_solver_settings_t {
   bool barrier_presolve;      // true to use barrier presolve
   bool cudss_deterministic;   // true to use cuDSS deterministic mode, false for non-deterministic
   i_t cudss_nd_nlevels;       // -1 automatic/unset, else METIS nested-dissection depth for cuDSS
-  bool cudss_hybrid_mode;     // true for hybrid CPU/GPU factor storage in cuDSS
-  bool cudss_hybrid_execute_mode;  // true to overlap CPU/GPU work in cuDSS (only meaningful when
-                                   // cudss_hybrid_mode is true)
-  i_t cudss_host_nthreads;         // -1 automatic/unset, else host worker thread count for cuDSS
-                                   // (only takes effect when a cuDSS threading layer is loaded)
-  bool barrier;                    // true to use barrier method, false to use dual simplex method
+  bool barrier;               // true to use barrier method, false to use dual simplex method
   bool deterministic;  // true to use B&B deterministic mode, false to use non-deterministic mode
   bool eliminate_dense_columns;             // true to eliminate dense columns from A*D*A^T
   bool barrier_iterative_refinement;        // true to use iterative refinement for barrier method

cpp/src/grpc/codegen/field_registry.yaml

@@ -563,16 +563,8 @@ pdlp_settings:
       field_num: 34
       type: int32
       optional: true
-  - cudss_hybrid_mode:
-      field_num: 35
-      type: bool
-  - cudss_hybrid_execute_mode:
-      field_num: 36
-      type: bool
-  - cudss_host_nthreads:
-      field_num: 37
-      type: int32
-      optional: true
+  # field_num 35-37 previously used by cudss_hybrid_mode/cudss_hybrid_execute_mode/
+  # cudss_host_nthreads, removed — do not reuse these numbers.
   - barrier_iterative_refinement_method:
       field_num: 38
       type: int32

cpp/src/grpc/codegen/generated/cuopt_remote_data.proto

@@ -195,9 +195,6 @@ message PDLPSolverSettings {
   optional double barrier_step_scale = 32;
   optional int32 postsolve_info = 33;
   optional int32 cudss_nd_nlevels = 34;
-  bool cudss_hybrid_mode = 35;
-  bool cudss_hybrid_execute_mode = 36;
-  optional int32 cudss_host_nthreads = 37;
   optional int32 barrier_iterative_refinement_method = 38;
   PDLPWarmStartData warm_start_data = 50;
 }

cpp/src/grpc/codegen/generated/generated_pdlp_settings_to_proto.inc

@@ -37,9 +37,6 @@
   pb_settings->set_barrier_step_scale(settings.barrier_step_scale);
   pb_settings->set_postsolve_info(settings.postsolve_info);
   pb_settings->set_cudss_nd_nlevels(settings.cudss_nd_nlevels);
-  pb_settings->set_cudss_hybrid_mode(settings.cudss_hybrid_mode);
-  pb_settings->set_cudss_hybrid_execute_mode(settings.cudss_hybrid_execute_mode);
-  pb_settings->set_cudss_host_nthreads(settings.cudss_host_nthreads);
   pb_settings->set_barrier_iterative_refinement_method(settings.barrier_iterative_refinement_method);
   pb_settings->set_save_best_primal_so_far(settings.save_best_primal_so_far);
   pb_settings->set_first_primal_feasible(settings.first_primal_feasible);

cpp/src/grpc/codegen/generated/generated_proto_to_pdlp_settings.inc

@@ -85,11 +85,6 @@
   if (pb_settings.has_cudss_nd_nlevels()) {
     settings.cudss_nd_nlevels = pb_settings.cudss_nd_nlevels();
   }
-  settings.cudss_hybrid_mode = pb_settings.cudss_hybrid_mode();
-  settings.cudss_hybrid_execute_mode = pb_settings.cudss_hybrid_execute_mode();
-  if (pb_settings.has_cudss_host_nthreads()) {
-    settings.cudss_host_nthreads = pb_settings.cudss_host_nthreads();
-  }
   if (pb_settings.has_barrier_iterative_refinement_method()) {
     settings.barrier_iterative_refinement_method = pb_settings.barrier_iterative_refinement_method();
   }

cpp/src/math_optimization/solver_settings.cu

@@ -137,7 +137,6 @@ solver_settings_t<i_t, f_t>::solver_settings_t() : pdlp_settings(), mip_settings
     {CUOPT_DUALIZE, &pdlp_settings.dualize, -1, 1, -1},
     {CUOPT_ORDERING, &pdlp_settings.ordering, -1, 1, -1},
     {CUOPT_CUDSS_ND_NLEVELS, &pdlp_settings.cudss_nd_nlevels, -1, std::numeric_limits<i_t>::max(), -1},
-    {CUOPT_CUDSS_HOST_NTHREADS, &pdlp_settings.cudss_host_nthreads, -1, std::numeric_limits<i_t>::max(), -1},
     {CUOPT_BARRIER_ITERATIVE_REFINEMENT_METHOD, &pdlp_settings.barrier_iterative_refinement_method, 0, 1, 1},
     {CUOPT_BARRIER_DUAL_INITIAL_POINT, &pdlp_settings.barrier_dual_initial_point, -1, 1, -1},
     {CUOPT_POSTSOLVE_INFO, &pdlp_settings.postsolve_info, -1, 1, -1},
@@ -207,8 +206,6 @@ solver_settings_t<i_t, f_t>::solver_settings_t() : pdlp_settings(), mip_settings
     {CUOPT_CROSSOVER, &pdlp_settings.crossover, false},
     {CUOPT_ELIMINATE_DENSE_COLUMNS, &pdlp_settings.eliminate_dense_columns, true},
     {CUOPT_CUDSS_DETERMINISTIC, &pdlp_settings.cudss_deterministic, false},
-    {CUOPT_CUDSS_HYBRID_MODE, &pdlp_settings.cudss_hybrid_mode, false},
-    {CUOPT_CUDSS_HYBRID_EXECUTE_MODE, &pdlp_settings.cudss_hybrid_execute_mode, false},
     {CUOPT_DUAL_POSTSOLVE, &pdlp_settings.dual_postsolve, true},
     {CUOPT_BARRIER_ITERATIVE_REFINEMENT, &pdlp_settings.barrier_iterative_refinement, true},
     {CUOPT_MIP_PROBING, &mip_settings.probing, true},

cpp/src/pdlp/solve.cu

@@ -520,9 +520,6 @@ std::tuple<simplex::lp_solution_t<i_t, f_t>, simplex::lp_status_t, f_t, f_t, f_t
   barrier_settings.qcqp_ruiz_equilibration         = settings.qcqp_ruiz_equilibration;
   barrier_settings.cudss_deterministic             = settings.cudss_deterministic;
   barrier_settings.cudss_nd_nlevels                = settings.cudss_nd_nlevels;
-  barrier_settings.cudss_hybrid_mode               = settings.cudss_hybrid_mode;
-  barrier_settings.cudss_hybrid_execute_mode       = settings.cudss_hybrid_execute_mode;
-  barrier_settings.cudss_host_nthreads             = settings.cudss_host_nthreads;
   barrier_settings.barrier_relaxed_feasibility_tol = settings.tolerances.relative_primal_tolerance;
   barrier_settings.barrier_relaxed_optimality_tol  = settings.tolerances.relative_dual_tolerance;
   barrier_settings.barrier_relaxed_complementarity_tol = settings.tolerances.relative_gap_tolerance;