fix thrust build + more timer checks

Author: aliceb-nv

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,11 @@ 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);
+    return sol.get_solution(false, solver.get_solver_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/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>