MIP Row and Objective Scaling

ci/validate_wheel.sh

@@ -22,11 +22,11 @@ PYDISTCHECK_ARGS=(
 if [[ "${package_dir}" == "python/libcuopt" ]]; then
     if [[ "${RAPIDS_CUDA_MAJOR}" == "12" ]]; then
         PYDISTCHECK_ARGS+=(
-            --max-allowed-size-compressed '645Mi'
+            --max-allowed-size-compressed '650Mi'
         )
     else
         PYDISTCHECK_ARGS+=(
-            --max-allowed-size-compressed '490Mi'
+            --max-allowed-size-compressed '495Mi'
         )
     fi
 elif [[ "${package_dir}" != "python/cuopt" ]] && \

cpp/CMakeLists.txt

@@ -138,7 +138,8 @@ endif(BUILD_MSAN)
 # infrastructure files. Those files include abseil headers, and abseil's shared library
 # on conda-forge doesn't export Mutex::Dtor() in NDEBUG builds (abseil-cpp#1624).
 # Keeping NDEBUG defined for gRPC files makes the header inline an empty Dtor(),
-# avoiding the missing symbol at runtime.
+# avoiding the missing symbol at runtime.  Additionally, gRPC files are always
+# compiled with -DNDEBUG (see below) so Debug builds also avoid the missing symbol.
 if(DEFINE_ASSERT)
   add_definitions(-DASSERT_MODE)
   list(APPEND CUOPT_CUDA_FLAGS -UNDEBUG)
@@ -390,7 +391,7 @@ if(DEFINE_ASSERT)
 endif()
 
 # Add gRPC mapper files and generated protobuf sources
-list(APPEND CUOPT_SRC_FILES
+set(GRPC_INFRA_FILES
   ${PROTO_SRCS}
   ${GRPC_PROTO_SRCS}
   ${GRPC_SERVICE_SRCS}
@@ -401,6 +402,15 @@ list(APPEND CUOPT_SRC_FILES
   src/grpc/client/grpc_client.cpp
   src/grpc/client/solve_remote.cpp
 )
+list(APPEND CUOPT_SRC_FILES ${GRPC_INFRA_FILES})
+
+# Always keep NDEBUG defined for gRPC infrastructure files so that abseil
+# headers inline Mutex::Dtor() instead of emitting an external call.
+# The conda-forge abseil shared library is built with NDEBUG and does not
+# export that symbol (abseil-cpp#1624).  Without this, Debug builds fail
+# at runtime with "undefined symbol: absl::…::Mutex::Dtor".
+set_property(SOURCE ${GRPC_INFRA_FILES} DIRECTORY ${CMAKE_SOURCE_DIR}
+  APPEND PROPERTY COMPILE_OPTIONS "-DNDEBUG")
 
 add_library(cuopt SHARED
   ${CUOPT_SRC_FILES}

cpp/include/cuopt/linear_programming/constants.h

@@ -180,4 +180,9 @@
 #define CUOPT_PRESOLVE_PAPILO  1
 #define CUOPT_PRESOLVE_PSLP    2
 
+/* @brief MIP scaling mode constants */
+#define CUOPT_MIP_SCALING_OFF          0
+#define CUOPT_MIP_SCALING_ON           1
+#define CUOPT_MIP_SCALING_NO_OBJECTIVE 2
+
 #endif  // CUOPT_CONSTANTS_H

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

@@ -115,7 +115,7 @@ class mip_solver_settings_t {
 
   /** Initial primal solutions */
   std::vector<std::shared_ptr<rmm::device_uvector<f_t>>> initial_solutions;
-  bool mip_scaling = false;
+  int mip_scaling = CUOPT_MIP_SCALING_NO_OBJECTIVE;
   presolver_t presolver{presolver_t::Default};
   /**
    * @brief Determinism mode for MIP solver.

cpp/src/branch_and_bound/branch_and_bound.cpp

@@ -174,14 +174,14 @@ f_t sgn(f_t x)
   return x < 0 ? -1 : 1;
 }
 
-template <typename f_t>
-f_t relative_gap(f_t obj_value, f_t lower_bound)
+template <typename i_t, typename f_t>
+f_t compute_user_abs_gap(const lp_problem_t<i_t, f_t>& lp, f_t obj_value, f_t lower_bound)
 {
-  f_t user_mip_gap = obj_value == 0.0
-                       ? (lower_bound == 0.0 ? 0.0 : std::numeric_limits<f_t>::infinity())
-                       : std::abs(obj_value - lower_bound) / std::abs(obj_value);
-  if (std::isnan(user_mip_gap)) { return std::numeric_limits<f_t>::infinity(); }
-  return user_mip_gap;
+  // abs_gap = |user_obj - user_lower| = |obj_scale| * |obj_value - lower_bound|
+  // obj_constant cancels out in the subtraction; obj_scale sign must be removed via abs
+  f_t gap = std::abs(lp.obj_scale) * (obj_value - lower_bound);
+  if (gap < -1e-4) { CUOPT_LOG_ERROR("Gap is negative %e", gap); }
+  return gap;
 }
 
 template <typename i_t, typename f_t>
@@ -191,15 +191,15 @@ f_t user_relative_gap(const lp_problem_t<i_t, f_t>& lp, f_t obj_value, f_t lower
   f_t user_lower_bound = compute_user_objective(lp, lower_bound);
   f_t user_mip_gap     = user_obj == 0.0
                            ? (user_lower_bound == 0.0 ? 0.0 : std::numeric_limits<f_t>::infinity())
-                           : std::abs(user_obj - user_lower_bound) / std::abs(user_obj);
+                           : compute_user_abs_gap(lp, obj_value, lower_bound) / std::abs(user_obj);
   if (std::isnan(user_mip_gap)) { return std::numeric_limits<f_t>::infinity(); }
   return user_mip_gap;
 }
 
-template <typename f_t>
-std::string user_mip_gap(f_t obj_value, f_t lower_bound)
+template <typename i_t, typename f_t>
+std::string user_mip_gap(const lp_problem_t<i_t, f_t>& lp, f_t obj_value, f_t lower_bound)
 {
-  const f_t user_mip_gap = relative_gap(obj_value, lower_bound);
+  const f_t user_mip_gap = user_relative_gap(lp, obj_value, lower_bound);
   if (user_mip_gap == std::numeric_limits<f_t>::infinity()) {
     return "   -  ";
   } else {
@@ -319,7 +319,7 @@ void branch_and_bound_t<i_t, f_t>::report_heuristic(f_t obj)
   if (is_running_) {
     f_t user_obj         = compute_user_objective(original_lp_, obj);
     f_t user_lower       = compute_user_objective(original_lp_, get_lower_bound());
-    std::string user_gap = user_mip_gap<f_t>(user_obj, user_lower);
+    std::string user_gap = user_mip_gap<i_t, f_t>(original_lp_, obj, get_lower_bound());
 
     settings_.log.printf(
       "H                            %+13.6e    %+10.6e                               %s %9.2f\n",
@@ -329,9 +329,9 @@ void branch_and_bound_t<i_t, f_t>::report_heuristic(f_t obj)
       toc(exploration_stats_.start_time));
   } else {
     if (solving_root_relaxation_.load()) {
-      f_t user_obj         = compute_user_objective(original_lp_, obj);
-      f_t user_lower       = root_lp_current_lower_bound_.load();
-      std::string user_gap = user_mip_gap<f_t>(user_obj, user_lower);
+      f_t user_obj = compute_user_objective(original_lp_, obj);
+      std::string user_gap =
+        user_mip_gap<i_t, f_t>(original_lp_, obj, root_lp_current_lower_bound_.load());
       settings_.log.printf(
         "New solution from primal heuristics. Objective %+.6e. Gap %s. Time %.2f\n",
         user_obj,
@@ -356,7 +356,7 @@ void branch_and_bound_t<i_t, f_t>::report(
   const f_t user_lower       = compute_user_objective(original_lp_, lower_bound);
   const f_t iters            = static_cast<f_t>(exploration_stats_.total_lp_iters);
   const f_t iter_node        = nodes_explored > 0 ? iters / nodes_explored : iters;
-  const std::string user_gap = user_mip_gap<f_t>(user_obj, user_lower);
+  const std::string user_gap = user_mip_gap<i_t, f_t>(original_lp_, obj, lower_bound);
   if (work_time >= 0) {
     settings_.log.printf(
       "%c %10d   %10lu    %+13.6e    %+10.6e   %6d %6d   %7.1e     %s %9.2f %9.2f\n",
@@ -717,9 +717,9 @@ void branch_and_bound_t<i_t, f_t>::set_final_solution(mip_solution_t<i_t, f_t>&
     settings_.heuristic_preemption_callback();
   }
 
-  f_t gap              = upper_bound_ - lower_bound;
   f_t obj              = compute_user_objective(original_lp_, upper_bound_.load());
   f_t user_bound       = compute_user_objective(original_lp_, lower_bound);
+  f_t gap              = std::abs(obj - user_bound);
   f_t gap_rel          = user_relative_gap(original_lp_, upper_bound_.load(), lower_bound);
   bool is_maximization = original_lp_.obj_scale < 0.0;
 
@@ -1437,7 +1437,7 @@ void branch_and_bound_t<i_t, f_t>::plunge_with(branch_and_bound_worker_t<i_t, f_
   f_t lower_bound = get_lower_bound();
   f_t upper_bound = upper_bound_;
   f_t rel_gap     = user_relative_gap(original_lp_, upper_bound, lower_bound);
-  f_t abs_gap     = upper_bound - lower_bound;
+  f_t abs_gap     = compute_user_abs_gap(original_lp_, upper_bound, lower_bound);
 
   while (stack.size() > 0 && (solver_status_ == mip_status_t::UNSET && is_running_) &&
          rel_gap > settings_.relative_mip_gap_tol && abs_gap > settings_.absolute_mip_gap_tol) {
@@ -1528,13 +1528,13 @@ void branch_and_bound_t<i_t, f_t>::plunge_with(branch_and_bound_worker_t<i_t, f_
     lower_bound = get_lower_bound();
     upper_bound = upper_bound_;
     rel_gap     = user_relative_gap(original_lp_, upper_bound, lower_bound);
-    abs_gap     = upper_bound - lower_bound;
+    abs_gap     = compute_user_abs_gap(original_lp_, upper_bound, lower_bound);
   }
 
   lower_bound = get_lower_bound();
   upper_bound = upper_bound_;
   rel_gap     = user_relative_gap(original_lp_, upper_bound, lower_bound);
-  abs_gap     = upper_bound - lower_bound;
+  abs_gap     = compute_user_abs_gap(original_lp_, upper_bound, lower_bound);
 
   if (stack.size() > 0 &&
       (rel_gap <= settings_.relative_mip_gap_tol || abs_gap <= settings_.absolute_mip_gap_tol)) {
@@ -1581,7 +1581,7 @@ void branch_and_bound_t<i_t, f_t>::dive_with(branch_and_bound_worker_t<i_t, f_t>
   f_t lower_bound = get_lower_bound();
   f_t upper_bound = upper_bound_;
   f_t rel_gap     = user_relative_gap(original_lp_, upper_bound, lower_bound);
-  f_t abs_gap     = upper_bound - lower_bound;
+  f_t abs_gap     = compute_user_abs_gap(original_lp_, upper_bound, lower_bound);
 
   while (stack.size() > 0 && (solver_status_ == mip_status_t::UNSET && is_running_) &&
          rel_gap > settings_.relative_mip_gap_tol && abs_gap > settings_.absolute_mip_gap_tol) {
@@ -1636,7 +1636,7 @@ void branch_and_bound_t<i_t, f_t>::dive_with(branch_and_bound_worker_t<i_t, f_t>
     lower_bound = get_lower_bound();
     upper_bound = upper_bound_;
     rel_gap     = user_relative_gap(original_lp_, upper_bound, lower_bound);
-    abs_gap     = upper_bound - lower_bound;
+    abs_gap     = compute_user_abs_gap(original_lp_, upper_bound, lower_bound);
   }
 
   worker_pool_.return_worker_to_pool(worker);
@@ -1667,7 +1667,7 @@ void branch_and_bound_t<i_t, f_t>::run_scheduler()
 #endif
 
   f_t lower_bound     = get_lower_bound();
-  f_t abs_gap         = upper_bound_ - lower_bound;
+  f_t abs_gap         = compute_user_abs_gap(original_lp_, upper_bound_.load(), lower_bound);
   f_t rel_gap         = user_relative_gap(original_lp_, upper_bound_.load(), lower_bound);
   i_t last_node_depth = 0;
   i_t last_int_infeas = 0;
@@ -1777,7 +1777,7 @@ void branch_and_bound_t<i_t, f_t>::run_scheduler()
     }
 
     lower_bound = get_lower_bound();
-    abs_gap     = upper_bound_ - lower_bound;
+    abs_gap     = compute_user_abs_gap(original_lp_, upper_bound_.load(), lower_bound);
     rel_gap     = user_relative_gap(original_lp_, upper_bound_.load(), lower_bound);
 
     if (abs_gap <= settings_.absolute_mip_gap_tol || rel_gap <= settings_.relative_mip_gap_tol) {
@@ -1799,7 +1799,7 @@ void branch_and_bound_t<i_t, f_t>::single_threaded_solve()
   branch_and_bound_worker_t<i_t, f_t> worker(0, original_lp_, Arow_, var_types_, settings_);
 
   f_t lower_bound = get_lower_bound();
-  f_t abs_gap     = upper_bound_ - lower_bound;
+  f_t abs_gap     = compute_user_abs_gap(original_lp_, upper_bound_.load(), lower_bound);
   f_t rel_gap     = user_relative_gap(original_lp_, upper_bound_.load(), lower_bound);
 
   while (solver_status_ == mip_status_t::UNSET && abs_gap > settings_.absolute_mip_gap_tol &&
@@ -1844,7 +1844,7 @@ void branch_and_bound_t<i_t, f_t>::single_threaded_solve()
     plunge_with(&worker);
 
     lower_bound = get_lower_bound();
-    abs_gap     = upper_bound_ - lower_bound;
+    abs_gap     = compute_user_abs_gap(original_lp_, upper_bound_.load(), lower_bound);
     rel_gap     = user_relative_gap(original_lp_, upper_bound_.load(), lower_bound);
 
     if (abs_gap <= settings_.absolute_mip_gap_tol || rel_gap <= settings_.relative_mip_gap_tol) {
@@ -2466,7 +2466,7 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
       report(' ', obj, root_objective_, 0, num_fractional);
 
       f_t rel_gap = user_relative_gap(original_lp_, upper_bound_.load(), root_objective_);
-      f_t abs_gap = upper_bound_.load() - root_objective_;
+      f_t abs_gap = compute_user_abs_gap(original_lp_, upper_bound_.load(), root_objective_);
       if (rel_gap < settings_.relative_mip_gap_tol || abs_gap < settings_.absolute_mip_gap_tol) {
         set_solution_at_root(solution, cut_info);
         set_final_solution(solution, root_objective_);
@@ -2961,7 +2961,6 @@ void branch_and_bound_t<i_t, f_t>::run_deterministic_bfs_loop(
       worker.current_node = node;
 
       f_t upper_bound = worker.local_upper_bound;
-      f_t rel_gap     = user_relative_gap(original_lp_, upper_bound, node->lower_bound);
       if (node->lower_bound > upper_bound) {
         worker.current_node = nullptr;
         worker.record_fathomed(node, node->lower_bound);
@@ -3073,7 +3072,7 @@ void branch_and_bound_t<i_t, f_t>::deterministic_sync_callback()
 
   f_t lower_bound = deterministic_compute_lower_bound();
   f_t upper_bound = upper_bound_.load();
-  f_t abs_gap     = upper_bound - lower_bound;
+  f_t abs_gap     = compute_user_abs_gap(original_lp_, upper_bound, lower_bound);
   f_t rel_gap     = user_relative_gap(original_lp_, upper_bound, lower_bound);
 
   if (abs_gap <= settings_.absolute_mip_gap_tol || rel_gap <= settings_.relative_mip_gap_tol) {
@@ -3112,7 +3111,7 @@ void branch_and_bound_t<i_t, f_t>::deterministic_sync_callback()
 
   f_t obj              = compute_user_objective(original_lp_, upper_bound);
   f_t user_lower       = compute_user_objective(original_lp_, lower_bound);
-  std::string gap_user = user_mip_gap<f_t>(obj, user_lower);
+  std::string gap_user = user_mip_gap<i_t, f_t>(original_lp_, upper_bound, lower_bound);
 
   std::string idle_workers;
   i_t idle_count = 0;
@@ -3750,7 +3749,6 @@ void branch_and_bound_t<i_t, f_t>::deterministic_dive(
     stack.pop_front();
 
     // Prune check using snapshot upper bound
-    f_t rel_gap = user_relative_gap(original_lp_, worker.local_upper_bound, node_ptr->lower_bound);
     if (node_ptr->lower_bound > worker.local_upper_bound) {
       worker.recompute_bounds_and_basis = true;
       continue;

cpp/src/dual_simplex/phase2.cpp

@@ -3571,7 +3571,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase,
                           sum_perturb,
                           now);
       if (phase == 2 && settings.inside_mip == 1 && settings.dual_simplex_objective_callback) {
-        settings.dual_simplex_objective_callback(user_obj);
+        settings.dual_simplex_objective_callback(obj);
       }
     }
 

cpp/src/dual_simplex/user_problem.hpp

@@ -46,7 +46,7 @@ struct user_problem_t {
   std::vector<std::string> row_names;
   std::vector<std::string> col_names;
   f_t obj_constant;
-  f_t obj_scale;  // 1.0 for min, -1.0 for max
+  f_t obj_scale;  // positive for min, netagive for max
   bool objective_is_integral{false};
   std::vector<variable_type_t> var_types;
   std::vector<i_t> Q_offsets;

cpp/src/grpc/cuopt_remote.proto

@@ -162,7 +162,7 @@ message MIPSolverSettings {
   int32 num_cpu_threads = 12;
   int32 num_gpus = 13;
   int32 presolver = 14;
-  bool mip_scaling = 15;
+  int32 mip_scaling = 15;
 }
 
 // LP solve request

cpp/src/grpc/grpc_settings_mapper.cpp

@@ -230,7 +230,12 @@ void map_proto_to_mip_settings(const cuopt::remote::MIPSolverSettings& pb_settin
                            ? static_cast<presolver_t>(pv)
                            : presolver_t::Default;
   }
-  settings.mip_scaling = pb_settings.mip_scaling();
+  {
+    auto sv              = pb_settings.mip_scaling();
+    settings.mip_scaling = (sv >= CUOPT_MIP_SCALING_OFF && sv <= CUOPT_MIP_SCALING_NO_OBJECTIVE)
+                             ? sv
+                             : CUOPT_MIP_SCALING_ON;
+  }
 }
 
 // Explicit template instantiations

cpp/src/math_optimization/solver_settings.cu

@@ -146,6 +146,7 @@ solver_settings_t<i_t, f_t>::solver_settings_t() : pdlp_settings(), mip_settings
     {CUOPT_RANDOM_SEED, &mip_settings.seed, -1, std::numeric_limits<i_t>::max(), -1},
     {CUOPT_MIP_RELIABILITY_BRANCHING, &mip_settings.reliability_branching, -1, std::numeric_limits<i_t>::max(), -1},
     {CUOPT_PDLP_PRECISION, reinterpret_cast<int*>(&pdlp_settings.pdlp_precision), CUOPT_PDLP_DEFAULT_PRECISION, CUOPT_PDLP_MIXED_PRECISION, CUOPT_PDLP_DEFAULT_PRECISION},
+    {CUOPT_MIP_SCALING, &mip_settings.mip_scaling, CUOPT_MIP_SCALING_OFF, CUOPT_MIP_SCALING_NO_OBJECTIVE, CUOPT_MIP_SCALING_ON},
     // MIP heuristic hyper-parameters (hidden from default --help: name contains "hyper_")
     {CUOPT_MIP_HYPER_HEURISTIC_POPULATION_SIZE, &mip_settings.heuristic_params.population_size, 1, std::numeric_limits<i_t>::max(), 32, "max solutions in pool"},
     {CUOPT_MIP_HYPER_HEURISTIC_NUM_CPUFJ_THREADS, &mip_settings.heuristic_params.num_cpufj_threads, 0, std::numeric_limits<i_t>::max(), 8, "parallel CPU FJ climbers"},
@@ -163,7 +164,6 @@ solver_settings_t<i_t, f_t>::solver_settings_t() : pdlp_settings(), mip_settings
     {CUOPT_PER_CONSTRAINT_RESIDUAL, &pdlp_settings.per_constraint_residual, false},
     {CUOPT_SAVE_BEST_PRIMAL_SO_FAR, &pdlp_settings.save_best_primal_so_far, false},
     {CUOPT_FIRST_PRIMAL_FEASIBLE, &pdlp_settings.first_primal_feasible, false},
-    {CUOPT_MIP_SCALING, &mip_settings.mip_scaling, true},
     {CUOPT_MIP_HEURISTICS_ONLY, &mip_settings.heuristics_only, false},
     {CUOPT_LOG_TO_CONSOLE, &pdlp_settings.log_to_console, true},
     {CUOPT_LOG_TO_CONSOLE, &mip_settings.log_to_console, true},

cpp/src/mip_heuristics/CMakeLists.txt

@@ -19,6 +19,7 @@ set(MIP_LP_NECESSARY_FILES
 
 # Files that are MIP-specific and not needed for pure LP
 set(MIP_NON_LP_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/mip_scaling_strategy.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/solve.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/solver.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/diversity/assignment_hash_map.cu