Merge remote-tracking branch 'cuopt-nvidia/main' into mir_cuts_improve

Author: chris-maes

.github/release.yml

@@ -0,0 +1,24 @@
+changelog:
+  exclude:
+    labels:
+      - ignore-for-release
+      - dependencies
+    authors:
+      - rapids-bot[bot]
+      - dependabot[bot]
+  categories:
+    - title: "\U0001F6A8 Breaking Changes"
+      labels:
+        - breaking
+    - title: "\U0001F41B Bug Fixes"
+      labels:
+        - bug
+    - title: "\U0001F4D6 Documentation"
+      labels:
+        - doc
+    - title: "\U0001F680 New Features"
+      labels:
+        - feature request
+    - title: "\U0001F6E0\uFE0F Improvements"
+      labels:
+        - improvement

cpp/src/mip_heuristics/diversity/diversity_manager.cu

@@ -201,18 +201,20 @@ bool diversity_manager_t<i_t, f_t>::run_presolve(f_t time_limit)
       compute_probing_cache(ls.constraint_prop.bounds_update, *problem_ptr, probing_timer);
     if (problem_is_infeasible) { return false; }
   }
-  const bool remap_cache_ids = true;
-  trivial_presolve(*problem_ptr, remap_cache_ids);
-  if (!problem_ptr->empty && !check_bounds_sanity(*problem_ptr)) { return false; }
-  // May overconstrain if Papilo presolve has been run before
-  if (context.settings.presolver == presolver_t::None) {
-    if (!problem_ptr->empty) {
-      // do the resizing no-matter what, bounds presolve might not change the bounds but initial
-      // trivial presolve might have
-      ls.constraint_prop.bounds_update.resize(*problem_ptr);
-      ls.constraint_prop.conditional_bounds_update.update_constraint_bounds(
-        *problem_ptr, ls.constraint_prop.bounds_update);
-      if (!check_bounds_sanity(*problem_ptr)) { return false; }
+  if (!presolve_timer.check_time_limit()) {
+    const bool remap_cache_ids = true;
+    trivial_presolve(*problem_ptr, remap_cache_ids);
+    if (!problem_ptr->empty && !check_bounds_sanity(*problem_ptr)) { return false; }
+    // May overconstrain if Papilo presolve has been run before
+    if (context.settings.presolver == presolver_t::None) {
+      if (!problem_ptr->empty) {
+        // do the resizing no-matter what, bounds presolve might not change the bounds but initial
+        // trivial presolve might have
+        ls.constraint_prop.bounds_update.resize(*problem_ptr);
+        ls.constraint_prop.conditional_bounds_update.update_constraint_bounds(
+          *problem_ptr, ls.constraint_prop.bounds_update);
+        if (!check_bounds_sanity(*problem_ptr)) { return false; }
+      }
     }
   }
   stats.presolve_time = presolve_timer.elapsed_time();

cpp/src/mip_heuristics/solve.cu

@@ -153,6 +153,13 @@ mip_solution_t<i_t, f_t> run_mip(detail::problem_t<i_t, f_t>& problem,
   detail::trivial_presolve(scaled_problem);
 
   detail::mip_solver_t<i_t, f_t> solver(scaled_problem, settings, scaling, timer);
+  if (timer.check_time_limit()) {
+    CUOPT_LOG_INFO("Time limit reached before main solve");
+    detail::solution_t<i_t, f_t> sol(problem);
+    auto stats             = solver.get_solver_stats();
+    stats.total_solve_time = timer.elapsed_time();
+    return sol.get_solution(false, stats, false);
+  }
   auto scaled_sol                 = solver.run_solver();
   bool is_feasible_before_scaling = scaled_sol.get_feasible();
   scaled_sol.problem_ptr          = &problem;

cpp/src/mip_heuristics/solver.cu

@@ -134,6 +134,14 @@ solution_t<i_t, f_t> mip_solver_t<i_t, f_t>::run_solver()
     return sol;
   }
 
+  if (timer_.check_time_limit()) {
+    CUOPT_LOG_INFO("Time limit reached after presolve");
+    solution_t<i_t, f_t> sol(*context.problem_ptr);
+    context.stats.total_solve_time = timer_.elapsed_time();
+    context.problem_ptr->post_process_solution(sol);
+    return sol;
+  }
+
   // if the problem was reduced to a LP: run concurrent LP
   if (run_presolve && context.problem_ptr->n_integer_vars == 0) {
     CUOPT_LOG_INFO("Problem reduced to a LP, running concurrent LP");
@@ -285,6 +293,14 @@ solution_t<i_t, f_t> mip_solver_t<i_t, f_t>::run_solver()
                 std::placeholders::_5,
                 std::placeholders::_6);
 
+    if (timer_.check_time_limit()) {
+      CUOPT_LOG_INFO("Time limit reached during B&B setup");
+      solution_t<i_t, f_t> sol(*context.problem_ptr);
+      context.stats.total_solve_time = timer_.elapsed_time();
+      context.problem_ptr->post_process_solution(sol);
+      return sol;
+    }
+
     // Fork a thread for branch and bound
     // std::async and std::future allow us to get the return value of bb::solve()
     // without having to manually manage the thread

cpp/src/pdlp/swap_and_resize_helper.cuh

@@ -16,6 +16,7 @@
 #include <thrust/iterator/permutation_iterator.h>
 #include <thrust/iterator/transform_iterator.h>
 #include <thrust/iterator/zip_iterator.h>
+#include <thrust/tuple.h>
 #include <thrust/universal_vector.h>
 
 #include <cuda/std/tuple>

cpp/src/pdlp/utils.cuh

@@ -25,6 +25,7 @@
 #include <thrust/execution_policy.h>
 #include <thrust/functional.h>
 #include <thrust/transform_reduce.h>
+#include <thrust/tuple.h>
 
 namespace cuopt::linear_programming::detail {
 

cpp/src/routing/utilities/check_input.cu

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -17,6 +17,7 @@
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/logical.h>
 #include <thrust/pair.h>
+#include <thrust/tuple.h>
 #include <cuda/std/functional>
 
 #include <unordered_set>

cpp/src/utilities/copy_helpers.hpp

@@ -15,6 +15,7 @@
 #include <rmm/exec_policy.hpp>
 
 #include <thrust/transform.h>
+#include <thrust/tuple.h>
 #include <thrust/universal_vector.h>
 
 #include <cuda/std/functional>

cpp/src/utilities/cuda_helpers.cuh

@@ -10,6 +10,7 @@
 #include <utilities/macros.cuh>
 
 #include <thrust/host_vector.h>
+#include <thrust/tuple.h>
 #include <mutex>
 #include <raft/core/device_span.hpp>
 #include <raft/util/cuda_utils.cuh>

python/cuopt_server/cuopt_server/tests/test_bill_logging.py

@@ -1,7 +1,8 @@
-# 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
 
 import json
+import os
 import platform
 import shutil
 import signal
@@ -29,16 +30,12 @@ def test_time_limit_logs():
     )
     dataset = json.load(open(dataset_path))
     client = RequestClient(port=5010)
-    env = {
-        "CUOPT_SERVER_IP": "127.0.0.1",
-        "CUOPT_SERVER_PORT": "5010",
-        "CUOPT_SERVER_LOG_LEVEL": "debug",
-        "CUOPT_MAX_SOLVE_TIME_LIMIT": "5",
-    }
+    env = os.environ.copy()
+    env["CUOPT_MAX_SOLVE_TIME_LIMIT"] = "5"
 
     url = "/cuopt/"
 
-    cmd = python_path + " " + server_script
+    cmd = python_path + " " + server_script + " -i 127.0.0.1 -p 5010 -l debug"
     process = pexpect.spawn(cmd, env=env)
 
     try: