handle ai reviews

Author: akifcorduk

cpp/src/cuts/cuts.cpp

@@ -1246,14 +1246,13 @@ bool cut_generation_t<i_t, f_t>::generate_clique_cuts(
     kept_adj_entries += adj.size();
 #ifdef ASSERT_MODE
     {
-      std::unordered_set<i_t> adj_check;
-      adj_check.reserve(adj.size());
+      std::unordered_set<i_t> adj_global;
+      adj_global.reserve(adj.size());
       for (const auto neighbor : adj) {
-        cuopt_assert(adj_check.insert(neighbor).second, "Duplicate neighbor in adjacency list");
-        // Make sure no complementing variable is present in the adjacency list
-        // Given convention: if variable is j, its complement is j + num_vars (and vice versa)
-        i_t complement = (neighbor >= num_vars) ? (neighbor - num_vars) : (neighbor + num_vars);
-        cuopt_assert(adj_check.find(complement) == adj_check.end(),
+        i_t v = vertices[neighbor];
+        cuopt_assert(adj_global.insert(v).second, "Duplicate neighbor in adjacency list");
+        i_t complement = (v >= num_vars) ? (v - num_vars) : (v + num_vars);
+        cuopt_assert(adj_global.find(complement) == adj_global.end(),
                      "Adjacency list contains complementing variable");
       }
     }

cpp/src/mip_heuristics/diversity/diversity_manager.cu

@@ -8,7 +8,6 @@
 #include "cuda_profiler_api.h"
 #include "diversity_manager.cuh"
 
-#include <dual_simplex/simplex_solver_settings.hpp>
 #include <mip_heuristics/diversity/known_miplib_objectives.hpp>
 #include <mip_heuristics/mip_constants.hpp>
 #include <mip_heuristics/presolve/conflict_graph/clique_table.cuh>
@@ -26,17 +25,6 @@ constexpr bool fj_only_run = false;
 
 namespace cuopt::linear_programming::detail {
 
-const char* env_cut_configuration_name(env_cut_configuration_t config)
-{
-  switch (config) {
-    case env_cut_configuration_t::WITHOUT_CLIQUE: return "cuts_without_clique";
-    case env_cut_configuration_t::WITH_CLIQUE: return "cuts_with_clique";
-    case env_cut_configuration_t::CLIQUE_ONLY: return "clique_only";
-    case env_cut_configuration_t::NONE: return "default";
-    default: return "unknown";
-  }
-}
-
 size_t fp_recombiner_config_t::max_n_of_vars_from_other =
   fp_recombiner_config_t::initial_n_of_vars_from_other;
 size_t ls_recombiner_config_t::max_n_of_vars_from_other =
@@ -92,6 +80,7 @@ diversity_manager_t<i_t, f_t>::diversity_manager_t(mip_solver_context_t<i_t, f_t
     ls_hash_map(*context.problem_ptr)
 {
   int max_config             = -1;
+  int env_config_id          = -1;
   const char* env_max_config = std::getenv("CUOPT_MAX_CONFIG");
   if (env_max_config != nullptr) {
     try {
@@ -117,52 +106,6 @@ diversity_manager_t<i_t, f_t>::diversity_manager_t(mip_solver_context_t<i_t, f_t
       "CUOPT_CONFIG_ID=%d is outside [0, %d). Ignoring cut override.", env_config_id, max_config);
     return;
   }
-
-  switch (env_config_id) {
-    case 0: env_cut_configuration = env_cut_configuration_t::WITHOUT_CLIQUE; break;
-    case 1: env_cut_configuration = env_cut_configuration_t::WITH_CLIQUE; break;
-    case 2: env_cut_configuration = env_cut_configuration_t::CLIQUE_ONLY; break;
-    default:
-      CUOPT_LOG_WARN(
-        "Unsupported CUOPT_CONFIG_ID=%d for cut configuration. "
-        "Expected 0 (without clique), 1 (with clique), or 2 (clique only).",
-        env_config_id);
-      env_cut_configuration = env_cut_configuration_t::NONE;
-      return;
-  }
-
-  CUOPT_LOG_INFO("Using cut configuration from CUOPT_CONFIG_ID=%d (%s)",
-                 env_config_id,
-                 env_cut_configuration_name(env_cut_configuration));
-}
-
-template <typename i_t, typename f_t>
-void diversity_manager_t<i_t, f_t>::apply_cut_configuration_from_env(
-  dual_simplex::simplex_solver_settings_t<i_t, f_t>& settings) const
-{
-  if (env_cut_configuration == env_cut_configuration_t::NONE) { return; }
-  switch (env_cut_configuration) {
-    case env_cut_configuration_t::WITHOUT_CLIQUE: settings.clique_cuts = 0; break;
-    case env_cut_configuration_t::WITH_CLIQUE: settings.clique_cuts = 1; break;
-    case env_cut_configuration_t::CLIQUE_ONLY:
-      settings.clique_cuts                = 1;
-      settings.mixed_integer_gomory_cuts  = 0;
-      settings.mir_cuts                   = 0;
-      settings.knapsack_cuts              = 0;
-      settings.strong_chvatal_gomory_cuts = 0;
-      break;
-    default: break;
-  }
-  settings.log.printf(
-    "Applied cut configuration from CUOPT_CONFIG_ID=%d (%s): mir=%d gomory=%d knapsack=%d "
-    "strong_cg=%d clique=%d\n",
-    env_config_id,
-    env_cut_configuration_name(env_cut_configuration),
-    settings.mir_cuts,
-    settings.mixed_integer_gomory_cuts,
-    settings.knapsack_cuts,
-    settings.strong_chvatal_gomory_cuts,
-    settings.clique_cuts);
 }
 
 // this function is to specialize the local search with config from diversity manager
@@ -256,7 +199,7 @@ bool diversity_manager_t<i_t, f_t>::run_presolve(f_t time_limit, timer_t global_
   if (run_probing_cache) {
     // Run probing cache before trivial presolve to discover variable implications
     const f_t max_time_on_probing = diversity_config.max_time_on_probing;
-    f_t time_for_probing_cache    = std::min(max_time_on_probing, time_limit);
+    f_t time_for_probing_cache    = std::min(max_time_on_probing, time_limit * 0.9);
     timer_t probing_timer{time_for_probing_cache};
     // this function computes probing cache, finds singletons, substitutions and changes the problem
     bool problem_is_infeasible =
@@ -270,7 +213,7 @@ bool diversity_manager_t<i_t, f_t>::run_presolve(f_t time_limit, timer_t global_
       !problem_ptr->empty) {
     // TODO this is just CPU time and blocking the GPU time.
     // execute this in parallel with something else.
-    f_t time_limit_for_clique_table = std::min(3., presolve_timer.remaining_time() / 5);
+    f_t time_limit_for_clique_table = std::min(3., presolve_timer.remaining_time());
     // if it is deterministic run until the end
     if (context.settings.determinism_mode == CUOPT_MODE_DETERMINISTIC) {
       time_limit_for_clique_table = std::numeric_limits<f_t>::infinity();
@@ -284,7 +227,7 @@ bool diversity_manager_t<i_t, f_t>::run_presolve(f_t time_limit, timer_t global_
     find_initial_cliques(host_problem,
                          context.settings.tolerances,
                          clique_table_ptr,
-                         presolve_timer,
+                         clique_timer,
                          modify_problem_with_cliques);
     if (modify_problem_with_cliques) {
       problem_ptr->set_constraints_from_host_user_problem(host_problem);

cpp/src/mip_heuristics/diversity/diversity_manager.cuh

@@ -29,22 +29,8 @@
 
 #include <cstdint>
 
-namespace cuopt::linear_programming::dual_simplex {
-template <typename i_t, typename f_t>
-struct simplex_solver_settings_t;
-}
-
 namespace cuopt::linear_programming::detail {
 
-enum class env_cut_configuration_t : int8_t {
-  NONE           = -1,
-  WITHOUT_CLIQUE = 0,
-  WITH_CLIQUE    = 1,
-  CLIQUE_ONLY    = 2,
-};
-
-const char* env_cut_configuration_name(env_cut_configuration_t config);
-
 template <typename i_t, typename f_t>
 class diversity_manager_t {
  public:
@@ -85,9 +71,6 @@ class diversity_manager_t {
   void set_simplex_solution(const std::vector<f_t>& solution,
                             const std::vector<f_t>& dual_solution,
                             f_t objective);
-  void apply_cut_configuration_from_env(
-    dual_simplex::simplex_solver_settings_t<i_t, f_t>& settings) const;
-
   mip_solver_context_t<i_t, f_t>& context;
   dual_simplex::branch_and_bound_t<i_t, f_t>* branch_and_bound_ptr;
   problem_t<i_t, f_t>* problem_ptr;
@@ -121,8 +104,6 @@ class diversity_manager_t {
   bool run_only_bp_recombiner{false};
   bool run_only_fp_recombiner{false};
   bool run_only_sub_mip_recombiner{false};
-  env_cut_configuration_t env_cut_configuration{env_cut_configuration_t::NONE};
-  int env_config_id{-1};
 };
 
 }  // namespace cuopt::linear_programming::detail

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

@@ -97,12 +97,11 @@ struct clique_table_t {
 };
 
 template <typename i_t, typename f_t>
-void find_initial_cliques(
-  dual_simplex::user_problem_t<i_t, f_t>& problem,
-  typename mip_solver_settings_t<i_t, f_t>::tolerances_t tolerances,
-  std::shared_ptr<clique_table_t<i_t, f_t>>* clique_table_out = nullptr,
-  cuopt::timer_t& timer = cuopt::timer_t(std::numeric_limits<double>::infinity()),
-  bool modify_problem   = false);
+void find_initial_cliques(dual_simplex::user_problem_t<i_t, f_t>& problem,
+                          typename mip_solver_settings_t<i_t, f_t>::tolerances_t tolerances,
+                          std::shared_ptr<clique_table_t<i_t, f_t>>* clique_table_out,
+                          cuopt::timer_t& timer,
+                          bool modify_problem);
 
 template <typename i_t, typename f_t>
 void build_clique_table(const dual_simplex::user_problem_t<i_t, f_t>& problem,

cpp/src/mip_heuristics/presolve/third_party_presolve.cpp

@@ -588,6 +588,7 @@ std::optional<third_party_presolve_result_t<i_t, f_t>> third_party_presolve_t<i_
 
   auto opt_problem = build_optimization_problem_from_pslp<i_t, f_t>(
     pslp_presolver_, op_problem.get_handle_ptr(), maximize_, original_obj_offset);
+  opt_problem.set_problem_name(op_problem.get_problem_name());
 
   return std::make_optional(third_party_presolve_result_t<i_t, f_t>{opt_problem, {}});
 }

cpp/src/mip_heuristics/solver.cu

@@ -223,7 +223,6 @@ solution_t<i_t, f_t> mip_solver_t<i_t, f_t>::run_solver()
     branch_and_bound_settings.clique_cuts   = context.settings.clique_cuts;
     branch_and_bound_settings.strong_chvatal_gomory_cuts =
       context.settings.strong_chvatal_gomory_cuts;
-    dm.apply_cut_configuration_from_env(branch_and_bound_settings);
     branch_and_bound_settings.reduced_cost_strengthening =
       context.settings.reduced_cost_strengthening;
     branch_and_bound_settings.cut_change_threshold  = context.settings.cut_change_threshold;