Clique Table and Preprocessing

cpp/CMakeLists.txt

@@ -533,6 +533,12 @@ endif()
 option(BUILD_MIP_BENCHMARKS "Build MIP benchmarks" OFF)
 if(BUILD_MIP_BENCHMARKS AND NOT BUILD_LP_ONLY)
   add_executable(solve_MIP ../benchmarks/linear_programming/cuopt/run_mip.cpp)
+  target_include_directories(solve_MIP
+    PRIVATE
+    "${CMAKE_CURRENT_SOURCE_DIR}/src"
+    PUBLIC
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+  )
 
   set_target_properties(solve_MIP
     PROPERTIES

cpp/src/dual_simplex/sparse_matrix.cpp

@@ -657,6 +657,12 @@ i_t csr_matrix_t<i_t, f_t>::check_matrix(std::string matrix_name) const
   return 0;
 }
 
+template <typename i_t, typename f_t>
+std::pair<i_t, i_t> csr_matrix_t<i_t, f_t>::get_constraint_range(i_t cstr_idx) const
+{
+  return std::make_pair(this->row_start[cstr_idx], this->row_start[cstr_idx + 1]);
+}
+
 // x <- x + alpha * A(:, j)
 template <typename i_t, typename f_t>
 void scatter_dense(const csc_matrix_t<i_t, f_t>& A, i_t j, f_t alpha, std::vector<f_t>& x)

cpp/src/dual_simplex/sparse_matrix.hpp

@@ -173,6 +173,8 @@ class csr_matrix_t {
     return true;
   }
 
+  // get constraint range
+  std::pair<i_t, i_t> get_constraint_range(i_t cstr_idx) const;
   i_t nz_max;                  // maximum number of nonzero entries
   i_t m;                       // number of rows
   i_t n;                       // number of cols

cpp/src/mip_heuristics/CMakeLists.txt

@@ -38,6 +38,7 @@ set(MIP_NON_LP_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/presolve/multi_probe.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/presolve/probing_cache.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/presolve/trivial_presolve.cu
+  ${CMAKE_CURRENT_SOURCE_DIR}/presolve/conflict_graph/clique_table.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/feasibility_jump/feasibility_jump.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/feasibility_jump/feasibility_jump_kernels.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/feasibility_jump/fj_cpu.cu)

cpp/src/mip_heuristics/diversity/diversity_manager.cu

@@ -9,6 +9,7 @@
 #include "diversity_manager.cuh"
 
 #include <mip_heuristics/mip_constants.hpp>
+#include <mip_heuristics/presolve/conflict_graph/clique_table.cuh>
 #include <mip_heuristics/presolve/probing_cache.cuh>
 #include <mip_heuristics/presolve/trivial_presolve.cuh>
 #include <mip_heuristics/problem/problem_helpers.cuh>
@@ -17,6 +18,8 @@
 
 #include <utilities/scope_guard.hpp>
 
+#include <memory>
+
 constexpr bool fj_only_run = false;
 
 namespace cuopt::linear_programming::detail {
@@ -204,16 +207,32 @@ bool diversity_manager_t<i_t, f_t>::run_presolve(f_t 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; }
+  if (!context.settings.heuristics_only && !problem_ptr->empty) {
+    dual_simplex::user_problem_t<i_t, f_t> host_problem(problem_ptr->handle_ptr);
+    problem_ptr->get_host_user_problem(host_problem);
+    std::shared_ptr<clique_table_t<i_t, f_t>> clique_table;
+    find_initial_cliques(host_problem, context.settings.tolerances, presolve_timer);
+    problem_ptr->set_constraints_from_host_user_problem(host_problem);
+    cuopt_assert(host_problem.lower.size() == static_cast<size_t>(problem_ptr->n_variables),
+                 "host lower bound size mismatch");
+    cuopt_assert(host_problem.upper.size() == static_cast<size_t>(problem_ptr->n_variables),
+                 "host upper bound size mismatch");
+    std::vector<i_t> all_var_indices(problem_ptr->n_variables);
+    std::iota(all_var_indices.begin(), all_var_indices.end(), 0);
+    problem_ptr->update_variable_bounds(all_var_indices, host_problem.lower, host_problem.upper);
+    trivial_presolve(*problem_ptr, remap_cache_ids);
+  }
   // 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.bounds_update.upd.init_changed_constraints(problem_ptr->handle_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 (!check_bounds_sanity(*problem_ptr)) { return false; }
   }
   stats.presolve_time = presolve_timer.elapsed_time();
   lp_optimal_solution.resize(problem_ptr->n_variables, problem_ptr->handle_ptr->get_stream());

cpp/src/mip_heuristics/local_search/local_search.cu

@@ -209,7 +209,24 @@ bool local_search_t<i_t, f_t>::do_fj_solve(solution_t<i_t, f_t>& solution,
   if (time_limit == 0.) return solution.get_feasible();
 
   timer_t timer(time_limit);
-
+  const auto old_n_cstr_weights      = in_fj.cstr_weights.size();
+  const auto expected_n_cstr_weights = static_cast<size_t>(solution.problem_ptr->n_constraints);
+  // in case this is the first time run, resize
+  if (old_n_cstr_weights != expected_n_cstr_weights) {
+    in_fj.cstr_weights.resize(solution.problem_ptr->n_constraints,
+                              solution.handle_ptr->get_stream());
+    cuopt_assert(in_fj.cstr_weights.size() == expected_n_cstr_weights,
+                 "Constraint weights must match constraint count after resize");
+    // Initialize only newly grown entries; shrinking does not need initialization.
+    if (old_n_cstr_weights < expected_n_cstr_weights) {
+      cuopt_assert(old_n_cstr_weights <= in_fj.cstr_weights.size(),
+                   "Constraint weight fill start must be within range");
+      thrust::uninitialized_fill(solution.handle_ptr->get_thrust_policy(),
+                                 in_fj.cstr_weights.begin() + old_n_cstr_weights,
+                                 in_fj.cstr_weights.end(),
+                                 1.);
+    }
+  }
   auto h_weights          = cuopt::host_copy(in_fj.cstr_weights, solution.handle_ptr->get_stream());
   auto h_objective_weight = in_fj.objective_weight.value(solution.handle_ptr->get_stream());
   for (auto& cpu_fj : ls_cpu_fj) {