Clique Table and Preprocessing

cpp/CMakeLists.txt

@@ -507,6 +507,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

@@ -654,6 +654,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)
@@ -667,6 +673,19 @@ void scatter_dense(const csc_matrix_t<i_t, f_t>& A, i_t j, f_t alpha, std::vecto
   }
 }
 
+template <typename i_t, typename f_t>
+void csr_matrix_t<i_t, f_t>::insert_row(const std::vector<i_t>& vars,
+                                        const std::vector<f_t>& coeffs)
+{
+  assert(vars.size() == coeffs.size());
+  // insert the row into the matrix
+  this->row_start.push_back(this->row_start.back() + vars.size());
+  this->m++;
+  this->nz_max += vars.size();
+  this->j.insert(this->j.end(), vars.begin(), vars.end());
+  this->x.insert(this->x.end(), coeffs.begin(), coeffs.end());
+}
+
 // x <- x + alpha * A(:, j)
 template <typename i_t, typename f_t>
 void scatter_dense(const csc_matrix_t<i_t, f_t>& A,

cpp/src/dual_simplex/sparse_matrix.hpp

@@ -173,12 +173,18 @@ class csr_matrix_t {
     return true;
   }
 
+  // get constraint range
+  std::pair<i_t, i_t> get_constraint_range(i_t cstr_idx) const;
+
+  // insert a constraint into the matrix
+  void insert_row(const std::vector<i_t>& vars, const std::vector<f_t>& coeffs);
+
   i_t nz_max;                  // maximum number of nonzero entries
   i_t m;                       // number of rows
   i_t n;                       // number of cols
   std::vector<i_t> row_start;  // row pointers (size m + 1)
   std::vector<i_t> j;          // column inidices, size nz_max
-  std::vector<f_t> x;          // numerical valuse, size nz_max
+  std::vector<f_t> x;          // numerical values, size nz_max
 
   static_assert(std::is_signed_v<i_t>);
 };

cpp/src/mip/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/diversity/diversity_manager.cu

@@ -9,10 +9,12 @@
 #include "diversity_manager.cuh"
 
 #include <mip/mip_constants.hpp>
+#include <mip/presolve/conflict_graph/clique_table.cuh>
 #include <mip/presolve/probing_cache.cuh>
 #include <mip/presolve/trivial_presolve.cuh>
 #include <mip/problem/problem_helpers.cuh>
 
+#include <dual_simplex/user_problem.hpp>
 #include <linear_programming/solve.cuh>
 
 #include <utilities/scope_guard.hpp>
@@ -200,16 +202,23 @@ 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; }
-  // May overconstrain if Papilo presolve has been run before
-  if (!context.settings.presolve) {
-    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);
+  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);
+    find_initial_cliques(host_problem, context.settings.tolerances);
+    problem_ptr->set_constraints_from_host_user_problem(host_problem);
+    trivial_presolve(*problem_ptr, remap_cache_ids);
+  }
+  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);
+    // May overconstrain if Papilo presolve has been run before
+    if (!context.settings.presolve) {
       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/local_search/local_search.cu

@@ -153,7 +153,16 @@ 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);
-
+  // in case this is the first time run, resize
+  if (in_fj.cstr_weights.size() != (size_t)solution.problem_ptr->n_constraints) {
+    in_fj.cstr_weights.resize(solution.problem_ptr->n_constraints,
+                              solution.handle_ptr->get_stream());
+    // reset weights since this is most likely the first call
+    thrust::uninitialized_fill(solution.handle_ptr->get_thrust_policy(),
+                               in_fj.cstr_weights.begin(),
+                               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) {