address review comments

Author: aliceb-nv

cpp/src/dual_simplex/bb_event.hpp

@@ -64,8 +64,8 @@ struct bb_event_t {
 
   bool operator<(const bb_event_t& other) const
   {
-    return std::tie(wut, worker_id, event_sequence) <
-           std::tie(other.wut, other.worker_id, other.event_sequence);
+    return std::tie(wut, worker_id, node_id, event_sequence) <
+           std::tie(other.wut, other.worker_id, other.node_id, other.event_sequence);
   }
 
   static bb_event_t make_branched(double work_unit_ts,

cpp/src/dual_simplex/bounds_strengthening.cpp

@@ -116,7 +116,7 @@ bool bounds_strengthening_t<i_t, f_t>::bounds_strengthening(
         const i_t col_start = A.col_start[j];
         const i_t col_end   = A.col_start[j + 1];
         for (i_t p = col_start; p < col_end; ++p) {
-          const i_t i           = A.i[p];
+          const i_t i           = A_i[p];
           constraint_changed[i] = true;
         }
       }
@@ -192,7 +192,7 @@ bool bounds_strengthening_t<i_t, f_t>::bounds_strengthening(
       const i_t col_end   = A.col_start[k + 1];
       nnz_processed += (col_end - col_start);
       for (i_t p = col_start; p < col_end; ++p) {
-        const i_t i = A.i[p];
+        const i_t i = A_i[p];
 
         if (!constraint_changed[i]) { continue; }
         const f_t a_ik = A_x[p];

cpp/src/dual_simplex/branch_and_bound.cpp

@@ -2385,6 +2385,7 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
     lower_bound = node_queue_.best_first_queue_size() > 0 ? node_queue_.get_lower_bound()
                                                           : search_tree_.root.lower_bound;
   }
+  solver_status_ = determinism_global_termination_status_;
   set_final_solution(solution, lower_bound);
   return solver_status_;
 }

cpp/src/dual_simplex/deterministic_workers.hpp

@@ -268,7 +268,7 @@ class determinism_bfs_worker_t
   {
     record_event(bb_event_t<i_t, f_t>::make_branched(this->clock,
                                                      this->worker_id,
-                                                     node->node_id,
+                                                     node->creation_seq,
                                                      down_child_id,
                                                      up_child_id,
                                                      node->lower_bound,
@@ -282,7 +282,7 @@ class determinism_bfs_worker_t
   void record_integer_solution(mip_node_t<i_t, f_t>* node, f_t objective)
   {
     record_event(bb_event_t<i_t, f_t>::make_integer_solution(
-      this->clock, this->worker_id, node->node_id, objective));
+      this->clock, this->worker_id, node->creation_seq, objective));
     ++nodes_processed_this_horizon;
     ++this->total_nodes_processed;
     ++this->total_integer_solutions;
@@ -291,7 +291,7 @@ class determinism_bfs_worker_t
   void record_fathomed(mip_node_t<i_t, f_t>* node, f_t lower_bound)
   {
     record_event(bb_event_t<i_t, f_t>::make_fathomed(
-      this->clock, this->worker_id, node->node_id, lower_bound));
+      this->clock, this->worker_id, node->creation_seq, lower_bound));
     ++nodes_processed_this_horizon;
     ++this->total_nodes_processed;
     ++total_nodes_pruned;
@@ -300,15 +300,16 @@ class determinism_bfs_worker_t
   void record_infeasible(mip_node_t<i_t, f_t>* node)
   {
     record_event(
-      bb_event_t<i_t, f_t>::make_infeasible(this->clock, this->worker_id, node->node_id));
+      bb_event_t<i_t, f_t>::make_infeasible(this->clock, this->worker_id, node->creation_seq));
     ++nodes_processed_this_horizon;
     ++this->total_nodes_processed;
     ++total_nodes_infeasible;
   }
 
   void record_numerical(mip_node_t<i_t, f_t>* node)
   {
-    record_event(bb_event_t<i_t, f_t>::make_numerical(this->clock, this->worker_id, node->node_id));
+    record_event(
+      bb_event_t<i_t, f_t>::make_numerical(this->clock, this->worker_id, node->creation_seq));
     ++nodes_processed_this_horizon;
     ++this->total_nodes_processed;
   }

cpp/src/dual_simplex/phase2.cpp

@@ -3371,7 +3371,7 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase,
 
     // Feature logging for regression training (every FEATURE_LOG_INTERVAL iterations)
     if ((iter % FEATURE_LOG_INTERVAL) == 0 && work_unit_context) {
-      i_t iters_elapsed = iter - last_feature_log_iter;
+      [[maybe_unused]] i_t iters_elapsed = iter - last_feature_log_iter;
 
       auto [total_loads, total_stores] = aggregator.collect_and_flush();
       // features.byte_loads              = total_loads;

cpp/tests/mip/determinism_test.cu

@@ -164,6 +164,11 @@ TEST_F(DeterministicBBTest, reproducible_solution_vector)
   settings.num_cpu_threads  = 8;
   settings.work_limit       = 2;
 
+  auto seed = std::random_device{}() & 0x7fffffff;
+
+  std::cout << "Tested with seed " << seed << "\n";
+  settings.seed = seed;
+
   auto solution1 = solve_mip(&handle_, problem, settings);
   auto solution2 = solve_mip(&handle_, problem, settings);