wip

Author: akifcorduk

cpp/src/mip_heuristics/diversity/diversity_manager.cu

@@ -209,7 +209,7 @@ bool diversity_manager_t<i_t, f_t>::run_presolve(f_t time_limit, timer_t global_
   if (!problem_ptr->empty && !check_bounds_sanity(*problem_ptr)) { return false; }
   if (!presolve_timer.check_time_limit() && !context.settings.heuristics_only &&
       !problem_ptr->empty) {
-    timer_t clique_timer(15.);
+    timer_t clique_timer(std::numeric_limits<double>::infinity());
     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;

cpp/src/mip_heuristics/presolve/conflict_graph/clique_table.cu

@@ -28,6 +28,7 @@
 #include <utilities/logger.hpp>
 #include <utilities/macros.cuh>
 #include <utilities/timer.hpp>
+#include <utility>
 
 namespace cuopt::linear_programming::detail {
 
@@ -396,10 +397,10 @@ bool clique_table_t<i_t, f_t>::check_adjacency(i_t var_idx1, i_t var_idx2)
 // if this is called outside extend clique, csr matrix should be converted into csc and copied into
 // problem because the problem is partly modified
 template <typename i_t, typename f_t>
-void insert_clique_into_problem(const std::vector<i_t>& clique,
-                                dual_simplex::user_problem_t<i_t, f_t>& problem,
-                                dual_simplex::csr_matrix_t<i_t, f_t>& A,
-                                f_t coeff_scale)
+i_t insert_clique_into_problem(const std::vector<i_t>& clique,
+                               dual_simplex::user_problem_t<i_t, f_t>& problem,
+                               dual_simplex::csr_matrix_t<i_t, f_t>& A,
+                               f_t coeff_scale)
 {
   // convert vertices into original vars
   f_t rhs_offset = 0.;
@@ -421,12 +422,14 @@ void insert_clique_into_problem(const std::vector<i_t>& clique,
   f_t rhs = coeff_scale - rhs_offset;
   // insert the new clique into the problem as a new constraint
   dual_simplex::sparse_vector_t<i_t, f_t> new_row(A.n, new_vars.size());
-  new_row.i = std::move(new_vars);
-  new_row.x = std::move(new_coeffs);
+  new_row.i            = std::move(new_vars);
+  new_row.x            = std::move(new_coeffs);
+  i_t inserted_row_idx = A.m;
   A.append_row(new_row);
   problem.row_sense.push_back('L');
   problem.rhs.push_back(rhs);
   problem.row_names.push_back("Clique" + std::to_string(problem.row_names.size()));
+  return inserted_row_idx;
 }
 
 template <typename i_t, typename f_t>
@@ -438,9 +441,13 @@ bool extend_clique(const std::vector<i_t>& clique,
                    i_t min_extension_gain,
                    i_t remaining_rows_budget,
                    i_t remaining_nnz_budget,
-                   i_t& inserted_row_nnz)
+                   i_t& inserted_row_nnz,
+                   i_t& inserted_row_idx,
+                   i_t& extended_clique_idx)
 {
   inserted_row_nnz        = 0;
+  inserted_row_idx        = -1;
+  extended_clique_idx     = -1;
   i_t smallest_degree     = std::numeric_limits<i_t>::max();
   i_t smallest_degree_var = -1;
   // find smallest degree vertex in the current set packing constraint
@@ -498,6 +505,7 @@ bool extend_clique(const std::vector<i_t>& clique,
                       complement_conflict_var);
       cuopt_assert(n_of_complement_conflicts == 1, "There can only be one complement conflict");
       // Keep the discovered extension in the clique table for downstream dominance checks.
+      extended_clique_idx = static_cast<i_t>(clique_table.first.size());
       clique_table.first.push_back(new_clique);
       for (const auto& var_idx : new_clique) {
         clique_table.var_degrees[var_idx] = -1;
@@ -524,6 +532,7 @@ bool extend_clique(const std::vector<i_t>& clique,
     } else {
       // Keep the discovered extension in the clique table even when row insertion is skipped by
       // row/nnz budgets.
+      extended_clique_idx = static_cast<i_t>(clique_table.first.size());
       clique_table.first.push_back(new_clique);
       for (const auto& var_idx : new_clique) {
         clique_table.var_degrees[var_idx] = -1;
@@ -538,7 +547,7 @@ bool extend_clique(const std::vector<i_t>& clique,
         return true;
       }
       // insert the new clique into the problem as a new constraint
-      insert_clique_into_problem(new_clique, problem, A, coeff_scale);
+      inserted_row_idx = insert_clique_into_problem(new_clique, problem, A, coeff_scale);
       inserted_row_nnz = static_cast<i_t>(new_clique.size());
     }
   }
@@ -553,21 +562,25 @@ i_t extend_cliques(const std::vector<knapsack_constraint_t<i_t, f_t>>& knapsack_
                    clique_table_t<i_t, f_t>& clique_table,
                    dual_simplex::user_problem_t<i_t, f_t>& problem,
                    dual_simplex::csr_matrix_t<i_t, f_t>& A,
+                   std::vector<std::pair<i_t, i_t>>& inserted_extended_rows,
                    cuopt::timer_t& timer)
 {
-  constexpr i_t min_extension_gain       = 2;
-  constexpr i_t extension_yield_window   = 64;
+  constexpr i_t min_extension_gain       = 0;
+  constexpr i_t extension_yield_window   = 100000000;
   constexpr i_t min_successes_per_window = 1;
 
-  i_t base_rows      = A.m;
-  i_t base_nnz       = A.row_start[A.m];
-  i_t max_added_rows = std::max<i_t>(8, base_rows / 50);
-  i_t max_added_nnz  = std::max<i_t>(8 * clique_table.max_clique_size_for_extension, base_nnz / 50);
-
+  i_t base_rows = A.m;
+  i_t base_nnz  = A.row_start[A.m];
+  // i_t max_added_rows = std::max<i_t>(8, base_rows / 50);
+  // i_t max_added_nnz  = std::max<i_t>(8 * clique_table.max_clique_size_for_extension, base_nnz /
+  // 50);
+  i_t max_added_rows   = std::numeric_limits<i_t>::max();
+  i_t max_added_nnz    = std::numeric_limits<i_t>::max();
   i_t added_rows       = 0;
   i_t added_nnz        = 0;
   i_t window_attempts  = 0;
   i_t window_successes = 0;
+  inserted_extended_rows.clear();
 
   CUOPT_LOG_DEBUG("Clique extension heuristics: min_gain=%d row_budget=%d nnz_budget=%d",
                   min_extension_gain,
@@ -622,20 +635,27 @@ i_t extend_cliques(const std::vector<knapsack_constraint_t<i_t, f_t>>& knapsack_
     for (const auto& entry : knapsack_constraint.entries) {
       clique.push_back(entry.col);
     }
-    i_t inserted_row_nnz = 0;
-    f_t coeff_scale      = knapsack_constraint.entries[0].val;
-    bool extended_clique = extend_clique(clique,
+    i_t inserted_row_nnz    = 0;
+    i_t inserted_row_idx    = -1;
+    i_t extended_clique_idx = -1;
+    f_t coeff_scale         = knapsack_constraint.entries[0].val;
+    bool extended_clique    = extend_clique(clique,
                                          clique_table,
                                          problem,
                                          A,
                                          coeff_scale,
                                          min_extension_gain,
                                          max_added_rows - added_rows,
                                          max_added_nnz - added_nnz,
-                                         inserted_row_nnz);
+                                         inserted_row_nnz,
+                                         inserted_row_idx,
+                                         extended_clique_idx);
     if (extended_clique) {
       n_extended_cliques++;
       window_successes++;
+      if (inserted_row_idx >= 0 && extended_clique_idx >= 0) {
+        inserted_extended_rows.emplace_back(inserted_row_idx, extended_clique_idx);
+      }
       if (inserted_row_nnz > 0) {
         added_rows++;
         added_nnz += inserted_row_nnz;
@@ -690,6 +710,7 @@ void remove_dominated_cliques(
   std::unordered_set<i_t>& set_packing_constraints,
   const std::vector<knapsack_constraint_t<i_t, f_t>>& knapsack_constraints,
   i_t n_extended_cliques,
+  const std::vector<std::pair<i_t, i_t>>& inserted_extended_rows,
   cuopt::timer_t& timer)
 {
   // TODO check if we need to add the dominance for the table itself
@@ -715,14 +736,18 @@ void remove_dominated_cliques(
   if (!time_limit_reached) {
     CUOPT_LOG_DEBUG("Constraint variable lists built: %zu", set_packing_constraints.size());
     constexpr size_t dominance_window = 100;
-    struct clique_sig_t {
-      i_t knapsack_idx;
+    struct dominance_sig_t {
+      bool is_extended;
+      i_t source_idx;
       i_t row_idx;
       i_t size;
       long long signature;
     };
-    std::vector<clique_sig_t> sp_sigs;
-    sp_sigs.reserve(set_packing_constraints.size());
+    std::vector<std::vector<i_t>> extended_cstr_vars;
+    extended_cstr_vars.reserve(inserted_extended_rows.size());
+    std::unordered_map<i_t, i_t> clique_idx_to_row_idx;
+    std::vector<dominance_sig_t> dominance_sigs;
+    dominance_sigs.reserve(set_packing_constraints.size() + inserted_extended_rows.size());
     CUOPT_LOG_DEBUG("Building set packing signatures");
     for (const auto knapsack_idx : set_packing_constraints) {
       if (timer.check_time_limit()) {
@@ -735,13 +760,38 @@ void remove_dominated_cliques(
       for (auto v : vars) {
         signature += static_cast<long long>(v);
       }
-      sp_sigs.push_back({knapsack_idx,
-                         knapsack_constraints[knapsack_idx].cstr_idx,
-                         static_cast<i_t>(vars.size()),
-                         signature});
+      dominance_sigs.push_back({false,
+                                knapsack_idx,
+                                knapsack_constraints[knapsack_idx].cstr_idx,
+                                static_cast<i_t>(vars.size()),
+                                signature});
     }
-    CUOPT_LOG_DEBUG("Sorting signatures: %zu", sp_sigs.size());
-    std::sort(sp_sigs.begin(), sp_sigs.end(), [](const auto& a, const auto& b) {
+    for (const auto& inserted : inserted_extended_rows) {
+      if (timer.check_time_limit()) {
+        time_limit_reached = true;
+        break;
+      }
+      const i_t row_idx    = inserted.first;
+      const i_t clique_idx = inserted.second;
+      if (clique_idx < 0 || clique_idx >= static_cast<i_t>(clique_table.first.size())) { continue; }
+      if (row_idx < 0 || row_idx >= static_cast<i_t>(problem.row_sense.size())) { continue; }
+      std::vector<i_t> vars(clique_table.first[clique_idx].begin(),
+                            clique_table.first[clique_idx].end());
+      std::sort(vars.begin(), vars.end());
+      vars.erase(std::unique(vars.begin(), vars.end()), vars.end());
+      if (vars.empty()) { continue; }
+      long long signature = 0;
+      for (auto v : vars) {
+        signature += static_cast<long long>(v);
+      }
+      i_t source_idx = static_cast<i_t>(extended_cstr_vars.size());
+      extended_cstr_vars.push_back(std::move(vars));
+      clique_idx_to_row_idx[clique_idx] = row_idx;
+      dominance_sigs.push_back(
+        {true, source_idx, row_idx, static_cast<i_t>(extended_cstr_vars.back().size()), signature});
+    }
+    CUOPT_LOG_DEBUG("Sorting signatures: %zu", dominance_sigs.size());
+    std::sort(dominance_sigs.begin(), dominance_sigs.end(), [](const auto& a, const auto& b) {
       if (a.signature != b.signature) { return a.signature < b.signature; }
       return a.size < b.size;
     });
@@ -782,11 +832,12 @@ void remove_dominated_cliques(
       }
     };
     auto find_window_end = [&](long long signature) {
-      auto it = std::upper_bound(
-        sp_sigs.begin(), sp_sigs.end(), signature, [](long long value, const auto& a) {
-          return value < a.signature;
-        });
-      return static_cast<size_t>(std::distance(sp_sigs.begin(), it));
+      auto it =
+        std::upper_bound(dominance_sigs.begin(),
+                         dominance_sigs.end(),
+                         signature,
+                         [](long long value, const auto& a) { return value < a.signature; });
+      return static_cast<size_t>(std::distance(dominance_sigs.begin(), it));
     };
     CUOPT_LOG_DEBUG("Scanning extended cliques for dominance");
     for (i_t i = 0; i < n_extended_cliques; i++) {
@@ -803,6 +854,10 @@ void remove_dominated_cliques(
       cuopt_assert(
         std::unique(curr_clique_vars.begin(), curr_clique_vars.end()) == curr_clique_vars.end(),
         "Clique variables are not unique");
+      i_t current_row_idx = -1;
+      if (auto it = clique_idx_to_row_idx.find(clique_idx); it != clique_idx_to_row_idx.end()) {
+        current_row_idx = it->second;
+      }
       long long signature = 0;
       for (auto v : curr_clique_vars) {
         signature += static_cast<long long>(v);
@@ -811,9 +866,11 @@ void remove_dominated_cliques(
       size_t end   = find_window_end(signature);
       size_t start = (end > dominance_window) ? (end - dominance_window) : 0;
       for (size_t idx = end; idx > start; idx--) {
-        size_t cand_idx     = idx - 1;
-        const auto& sp      = sp_sigs[cand_idx];
-        const auto& vars_sp = cstr_vars[sp.knapsack_idx];
+        size_t cand_idx = idx - 1;
+        const auto& sp  = dominance_sigs[cand_idx];
+        if (sp.row_idx == current_row_idx) { continue; }
+        const auto& vars_sp =
+          sp.is_extended ? extended_cstr_vars[sp.source_idx] : cstr_vars[sp.source_idx];
         if (vars_sp.size() > curr_clique_vars.size()) { continue; }
         cuopt_assert(std::is_sorted(vars_sp.begin(), vars_sp.end()),
                      "vars_sp vector passed to is_subset is not sorted");
@@ -824,7 +881,7 @@ void remove_dominated_cliques(
             removal_marker[sp.row_idx]) {
           continue;
         }
-        if (knapsack_constraints[sp.knapsack_idx].is_set_partitioning) {
+        if (!sp.is_extended && knapsack_constraints[sp.source_idx].is_set_partitioning) {
           // note that we never deleter set partitioning constraints but it fixes some other
           // variables
           if (vars_sp.size() != curr_clique_vars.size()) {
@@ -1015,7 +1072,9 @@ void find_initial_cliques(dual_simplex::user_problem_t<i_t, f_t>& problem,
 #ifdef DEBUG_CLIQUE_TABLE
   t_maps = stage_timer.elapsed_time();
 #endif
-  i_t n_extended_cliques = extend_cliques(knapsack_constraints, clique_table, problem, A, timer);
+  std::vector<std::pair<i_t, i_t>> inserted_extended_rows;
+  i_t n_extended_cliques =
+    extend_cliques(knapsack_constraints, clique_table, problem, A, inserted_extended_rows, timer);
 #ifdef DEBUG_CLIQUE_TABLE
   t_extend = stage_timer.elapsed_time();
 #endif
@@ -1025,6 +1084,7 @@ void find_initial_cliques(dual_simplex::user_problem_t<i_t, f_t>& problem,
                            set_packing_constraints,
                            knapsack_constraints,
                            n_extended_cliques,
+                           inserted_extended_rows,
                            timer);
 #ifdef DEBUG_CLIQUE_TABLE
   t_remove = stage_timer.elapsed_time();

cpp/src/mip_heuristics/solve.cu

@@ -259,7 +259,7 @@ mip_solution_t<i_t, f_t> solve_mip(optimization_problem_t<i_t, f_t>& op_problem,
     if (!run_presolve) { CUOPT_LOG_INFO("Presolve is disabled, skipping"); }
 
     auto constexpr const dual_postsolve = false;
-    if (run_presolve) {
+    if (run_presolve && false) {
       detail::sort_csr(op_problem);
       // allocate not more than 10% of the time limit to presolve.
       // Note that this is not the presolve time, but the time limit for presolve.
@@ -302,7 +302,7 @@ mip_solution_t<i_t, f_t> solve_mip(optimization_problem_t<i_t, f_t>& op_problem,
 
     auto sol = run_mip(problem, settings, timer);
 
-    if (run_presolve) {
+    if (run_presolve && false) {
       auto status_to_skip = sol.get_termination_status() == mip_termination_status_t::TimeLimit ||
                             sol.get_termination_status() == mip_termination_status_t::WorkLimit ||
                             sol.get_termination_status() == mip_termination_status_t::Infeasible;