Fix adj_list check bug and improve clique cuts

benchmarks/linear_programming/cuopt/run_mip.cpp

@@ -6,6 +6,7 @@
 /* clang-format on */
 #include "initial_solution_reader.hpp"
 #include "mip_test_instances.hpp"
+#include "miplib2017_bks.hpp"
 
 #include <cstdio>
 #include <cuopt/linear_programming/io/parser.hpp>
@@ -239,6 +240,43 @@ int run_single_file(std::string file_path,
   } else {
     CUOPT_LOG_INFO("%s: no solution found", base_filename.c_str());
   }
+
+  // Per-instance "gap closed to BKS" stat. Emits a single
+  // grep-friendly "MIPLIBGapStat ..." line via printf so cross-branch
+  // comparison is just `grep '^MIPLIBGapStat' branchA.log` then diff.
+  // BKS values are looked up from the in-source MIPLIB2017 benchmark-set
+  // table (miplib2017_bks.hpp); unknown instances emit "opt=TBD"
+  // and infeasibility-flagged instances emit "opt=Infeasible".
+  {
+    const double _gap_seconds = std::chrono::duration_cast<std::chrono::milliseconds>(
+                                  std::chrono::high_resolution_clock::now() - start_run_solver)
+                                  .count() /
+                                1000.0;
+    std::string _status_str;
+    switch (solution.get_termination_status()) {
+      case cuopt::linear_programming::mip_termination_status_t::Optimal:
+        _status_str = "Optimal";
+        break;
+      case cuopt::linear_programming::mip_termination_status_t::FeasibleFound:
+        _status_str = "FeasibleFound";
+        break;
+      case cuopt::linear_programming::mip_termination_status_t::TimeLimit:
+        _status_str = "TimeLimit";
+        break;
+      case cuopt::linear_programming::mip_termination_status_t::Infeasible:
+        _status_str = "Infeasible";
+        break;
+      default: _status_str = "Other"; break;
+    }
+    cuopt_bench::print_miplib_gap_stat(base_filename,
+                                       solution,
+                                       _gap_seconds,
+                                       _status_str,
+                                       benchmark_info.root_lp_no_cuts,
+                                       benchmark_info.root_lp_with_cuts,
+                                       benchmark_info.cut_generation_time_sec);
+  }
+
   std::stringstream ss;
   int decimal_places = 2;
   double mip_gap     = solution.get_mip_gap();
@@ -534,31 +572,36 @@ int main(int argc, char* argv[])
     merge_result_files(out_dir, result_file, n_gpus, batch_num);
   } else {
     auto memory_resource = make_async();
+    auto run_single      = [&]() {
+      run_single_file(path,
+                      0,
+                      0,
+                      n_gpus,
+                      out_dir,
+                      initial_solution_file,
+                      heuristics_only,
+                      num_cpu_threads,
+                      write_log_file,
+                      log_to_console,
+                      reliability_branching,
+                      time_limit,
+                      work_limit,
+                      deterministic);
+    };
     if (memory_limit > 0) {
       auto limiting_adaptor =
         rmm::mr::limiting_resource_adaptor(memory_resource, memory_limit * 1024ULL * 1024ULL);
       rmm::mr::set_current_device_resource(limiting_adaptor);
+      run_single();
     } else if (track_allocations) {
       rmm::mr::tracking_resource_adaptor tracking_adaptor(memory_resource,
                                                           /*capture_stacks=*/true);
       rmm::mr::set_current_device_resource(tracking_adaptor);
+      run_single();
     } else {
       rmm::mr::set_current_device_resource(memory_resource);
+      run_single();
     }
-    run_single_file(path,
-                    0,
-                    0,
-                    n_gpus,
-                    out_dir,
-                    initial_solution_file,
-                    heuristics_only,
-                    num_cpu_threads,
-                    write_log_file,
-                    log_to_console,
-                    reliability_branching,
-                    time_limit,
-                    work_limit,
-                    deterministic);
   }
 
   return 0;

cpp/include/cuopt/linear_programming/mip/solver_settings.hpp

@@ -26,6 +26,27 @@ struct benchmark_info_t {
   double last_improvement_of_best_feasible    = 0;
   double last_improvement_after_recombination = 0;
   double objective_of_initial_population      = std::numeric_limits<double>::max();
+  // LP relaxation objective at the root node, BEFORE any cuts have been
+  // added. quiet_NaN() means "B&B did not run cut passes / value was
+  // never written" — distinguishes it from a legitimate 0.0.
+  double root_lp_no_cuts = std::numeric_limits<double>::quiet_NaN();
+  // LP relaxation objective at the root node, AFTER the full cut loop
+  // (final pass result). The dual gap "by cuts at the root" is then
+  //   gap_after_cuts = opt - root_lp_with_cuts        (in B&B's solver
+  //                                                    objective sense)
+  // and the classical "gap closed by cuts" metric is
+  //   gap_closed_pct = 100 * (root_lp_with_cuts - root_lp_no_cuts)
+  //                          / (opt - root_lp_no_cuts).
+  // quiet_NaN() means "B&B did not finish the cut loop / value not written".
+  double root_lp_with_cuts = std::numeric_limits<double>::quiet_NaN();
+
+  // Wall-clock time spent inside the root-node cut generation loop
+  // (sum of generate_cuts + score_cuts + check_for_duplicate_cuts +
+  // get_best_cuts + add_cuts + post-cut LP resolves), in seconds.
+  // Published by branch_and_bound.cpp::solve() at the same point that
+  // root_lp_with_cuts is finalised. quiet_NaN() means "cut loop did
+  // not run / value never written".
+  double cut_generation_time_sec = std::numeric_limits<double>::quiet_NaN();
 };
 
 // Forward declare solver_settings_t for friend class

cpp/src/branch_and_bound/branch_and_bound.cpp

@@ -11,6 +11,8 @@
 #include <branch_and_bound/pseudo_costs.hpp>
 #include <branch_and_bound/symmetry.hpp>
 
+#include <cuopt/linear_programming/mip/solver_settings.hpp>  // benchmark_info_t
+
 #include <cuts/cuts.hpp>
 #include <mip_heuristics/feasibility_jump/cpu_fj_thread.cuh>
 #include <mip_heuristics/mip_constants.hpp>
@@ -2361,6 +2363,11 @@ auto branch_and_bound_t<i_t, f_t>::do_cut_pass(
   }
   root_objective_ = compute_objective(original_lp_, root_relax_soln_.x);
 
+  if (settings_.benchmark_info_ptr != nullptr) {
+    settings_.benchmark_info_ptr->root_lp_with_cuts =
+      compute_user_objective(original_lp_, root_objective_);
+  }
+
   f_t remove_cuts_start_time = tic();
   mutex_original_lp_.lock();
   remove_cuts(original_lp_,
@@ -2479,7 +2486,7 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
       user_problem_t<i_t, f_t> problem_copy = original_problem_;
       timer_t timer(std::numeric_limits<double>::infinity());
       detail::find_initial_cliques(
-        problem_copy, tolerances_for_clique, &clique_table_, timer, false, clique_signal);
+        problem_copy, tolerances_for_clique, &clique_table_, timer, clique_signal);
     }
   }
 
@@ -2588,6 +2595,11 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
   cut_info_t<i_t, f_t> cut_info;
 
   if (num_fractional == 0) {
+    if (settings_.benchmark_info_ptr != nullptr) {
+      const double v = static_cast<double>(compute_user_objective(original_lp_, root_objective_));
+      settings_.benchmark_info_ptr->root_lp_no_cuts   = v;
+      settings_.benchmark_info_ptr->root_lp_with_cuts = v;
+    }
     set_solution_at_root(solution, cut_info);
     signal_extend_cliques_.store(true, std::memory_order_release);
 #pragma omp taskwait depend(in : *clique_signal)
@@ -2624,6 +2636,15 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
   f_t last_objective       = root_objective_;
   f_t root_relax_objective = root_objective_;
 
+  // Publish the no-cuts root LP value once. The with-cuts companion is
+  // published below after the cut loop terminates. Both go to the
+  // benchmark_info_t so callers (run_mip.cpp) can compute
+  // gap-closed-by-cuts without instrumenting the cut loop directly.
+  if (settings_.benchmark_info_ptr != nullptr) {
+    settings_.benchmark_info_ptr->root_lp_no_cuts =
+      compute_user_objective(original_lp_, root_relax_objective);
+  }
+
   constexpr bool enable_root_cut_cpufj = true;
   std::unique_ptr<detail::fj_cpu_task_t<i_t, f_t>> root_cut_cpufj_task;
   auto root_cut_cpufj_improvement_callback =
@@ -2652,7 +2673,17 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
   i_t cut_pool_size             = 0;
   for (i_t cut_pass = 0; cut_pass < settings_.max_cut_passes; cut_pass++) {
     if (num_fractional == 0) {
+      // LP relaxation is already integer-feasible — solved at the root
+      // by the cuts added so far (possibly zero). Publish the with-cuts
+      // value so the gap-closed line still has a non-NaN dual bound.
+      if (settings_.benchmark_info_ptr != nullptr) {
+        settings_.benchmark_info_ptr->root_lp_with_cuts =
+          compute_user_objective(original_lp_, root_objective_);
+      }
       set_solution_at_root(solution, cut_info);
+      if (settings_.benchmark_info_ptr != nullptr) {
+        settings_.benchmark_info_ptr->cut_generation_time_sec = toc(cut_generation_start_time);
+      }
       signal_extend_cliques_.store(true, std::memory_order_release);
 #pragma omp taskwait depend(in : *clique_signal)
       return mip_status_t::OPTIMAL;
@@ -2692,6 +2723,9 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
     }
 
     if (cut_pass_result.action == cut_pass_action_t::RETURN) {
+      if (settings_.benchmark_info_ptr != nullptr) {
+        settings_.benchmark_info_ptr->cut_generation_time_sec = toc(cut_generation_start_time);
+      }
       signal_extend_cliques_.store(true, std::memory_order_release);
 #pragma omp taskwait depend(in : *clique_signal)
       return cut_pass_result.status;
@@ -2714,8 +2748,18 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
     }
   }
 
+  // Publish the post-cuts root LP value.
+  if (settings_.benchmark_info_ptr != nullptr) {
+    settings_.benchmark_info_ptr->root_lp_with_cuts =
+      compute_user_objective(original_lp_, root_objective_);
+  }
+
   print_cut_info(settings_, cut_info);
   f_t cut_generation_time = toc(cut_generation_start_time);
+  // Publish cut-generation time for reporting.
+  if (settings_.benchmark_info_ptr != nullptr) {
+    settings_.benchmark_info_ptr->cut_generation_time_sec = cut_generation_time;
+  }
   if (cut_info.has_cuts()) {
     settings_.log.printf("Cut generation time: %.2f seconds\n", cut_generation_time);
     settings_.log.printf("Cut pool size  : %d\n", cut_pool_size);