handle ai reviewS

Author: akifcorduk

cpp/src/mip_heuristics/diversity/diversity_manager.cu

@@ -221,6 +221,7 @@ bool diversity_manager_t<i_t, f_t>::run_presolve(f_t time_limit)
       // 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);
     }

cpp/src/mip_heuristics/local_search/local_search.cu

@@ -209,15 +209,23 @@ 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 (in_fj.cstr_weights.size() != (size_t)solution.problem_ptr->n_constraints) {
+  if (old_n_cstr_weights != expected_n_cstr_weights) {
     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.);
+    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());

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

@@ -229,20 +229,30 @@ void remove_small_cliques(clique_table_t<i_t, f_t>& clique_table)
     }
   }
   for (size_t addtl_c = 0; addtl_c < clique_table.addtl_cliques.size(); addtl_c++) {
-    const auto& addtl_clique = clique_table.addtl_cliques[addtl_c];
+    const auto& addtl_clique   = clique_table.addtl_cliques[addtl_c];
+    const auto base_clique_idx = static_cast<size_t>(addtl_clique.clique_idx);
+    cuopt_assert(base_clique_idx < to_delete.size(),
+                 "Additional clique points to invalid base clique index");
+    // Remove additional cliques whose base clique is scheduled for deletion.
+    if (to_delete[base_clique_idx]) {
+      clique_table.addtl_cliques.erase(clique_table.addtl_cliques.begin() + addtl_c);
+      addtl_c--;
+      num_removed_addtl++;
+      continue;
+    }
     i_t size_of_clique =
-      clique_table.first[addtl_clique.clique_idx].size() - addtl_clique.start_pos_on_clique + 1;
+      clique_table.first[base_clique_idx].size() - addtl_clique.start_pos_on_clique + 1;
     if (size_of_clique < clique_table.min_clique_size) {
       // the items from first clique are already added to the adjlist
       // only add the items that are coming from the new var in the additional clique
       for (size_t i = addtl_clique.start_pos_on_clique;
-           i < clique_table.first[addtl_clique.clique_idx].size();
+           i < clique_table.first[base_clique_idx].size();
            i++) {
         // insert conflicts both way
-        clique_table.adj_list_small_cliques[clique_table.first[addtl_clique.clique_idx][i]].insert(
+        clique_table.adj_list_small_cliques[clique_table.first[base_clique_idx][i]].insert(
           addtl_clique.vertex_idx);
         clique_table.adj_list_small_cliques[addtl_clique.vertex_idx].insert(
-          clique_table.first[addtl_clique.clique_idx][i]);
+          clique_table.first[base_clique_idx][i]);
       }
       clique_table.addtl_cliques.erase(clique_table.addtl_cliques.begin() + addtl_c);
       addtl_c--;

cpp/src/mip_heuristics/problem/problem.cu

@@ -2065,9 +2065,9 @@ void problem_t<i_t, f_t>::set_constraints_from_host_user_problem(
   empty = (nnz == 0 && n_constraints == 0 && n_variables == 0);
 
   auto stream = handle_ptr->get_stream();
-  cuopt::device_copy(coefficients, csr_A.x.underlying(), stream);
-  cuopt::device_copy(variables, csr_A.j.underlying(), stream);
-  cuopt::device_copy(offsets, csr_A.row_start.underlying(), stream);
+  cuopt::device_copy(coefficients, csr_A.x, stream);
+  cuopt::device_copy(variables, csr_A.j, stream);
+  cuopt::device_copy(offsets, csr_A.row_start, stream);
 
   std::vector<f_t> h_constraint_lower_bounds(n_constraints);
   std::vector<f_t> h_constraint_upper_bounds(n_constraints);
@@ -2118,6 +2118,8 @@ void problem_t<i_t, f_t>::set_constraints_from_host_user_problem(
                  lp_state.prev_dual.end(),
                  f_t{0});
   }
+  handle_ptr->sync_stream();
+  RAFT_CHECK_CUDA(stream);
 
   compute_transpose_of_problem();
   combined_bounds.resize(n_constraints, stream);