replaced locks with atomics

Author: nguidotti

cpp/src/dual_simplex/bnb_worker.hpp

@@ -179,10 +179,11 @@ class bnb_worker_pool_t {
     }
   }
 
+  // Here, we are assuming that the master is the only
+  // thread that can retrieve/pop an idle worker.
   bnb_worker_data_t<i_t, f_t>* get_idle_worker()
   {
     std::lock_guard<omp_mutex_t> lock(mutex_);
-
     if (idle_workers_.empty()) {
       return nullptr;
     } else {
@@ -191,6 +192,8 @@ class bnb_worker_pool_t {
     }
   }
 
+  // Here, we are assuming that the master is the only
+  // thread that can retrieve/pop an idle worker.
   void pop_idle_worker()
   {
     std::lock_guard<omp_mutex_t> lock(mutex_);
@@ -200,20 +203,6 @@ class bnb_worker_pool_t {
     }
   }
 
-  bnb_worker_data_t<i_t, f_t>* get_and_pop_idle_worker()
-  {
-    std::lock_guard<omp_mutex_t> lock(mutex_);
-
-    if (idle_workers_.empty()) {
-      return nullptr;
-    } else {
-      i_t idx = idle_workers_.front();
-      idle_workers_.pop_front();
-      num_idle_workers_--;
-      return workers_[idx].get();
-    }
-  }
-
   void return_worker_to_pool(bnb_worker_data_t<i_t, f_t>* worker)
   {
     worker->is_active = false;

cpp/src/dual_simplex/branch_and_bound.cpp

@@ -282,7 +282,7 @@ void branch_and_bound_t<i_t, f_t>::report(char symbol, f_t obj, f_t lower_bound,
   i_t nodes_unexplored = exploration_stats_.nodes_unexplored;
   f_t user_obj         = compute_user_objective(original_lp_, obj);
   f_t user_lower       = compute_user_objective(original_lp_, lower_bound);
-  f_t iter_node        = (f_t)exploration_stats_.total_lp_iters / nodes_explored;
+  f_t iter_node = nodes_explored > 0 ? (f_t)exploration_stats_.total_lp_iters / nodes_explored : 0;
   std::string user_gap = user_mip_gap<f_t>(user_obj, user_lower);
   settings_.log.printf("%c %10d   %10lu    %+13.6e    %+10.6e  %6d    %7.1e     %s %9.2f\n",
                        symbol,

cpp/src/dual_simplex/diving_heuristics.cpp

@@ -88,14 +88,12 @@ branch_variable_t<i_t> pseudocost_diving(pseudo_costs_t<i_t, f_t>& pc,
     f_t f_down               = solution[j] - std::floor(solution[j]);
     f_t f_up                 = std::ceil(solution[j]) - solution[j];
 
-    pc.pseudo_cost_mutex[j].lock();
     f_t pc_down = pc.pseudo_cost_num_down[j] != 0
                     ? pc.pseudo_cost_sum_down[j] / pc.pseudo_cost_num_down[j]
                     : pseudo_cost_down_avg;
 
     f_t pc_up = pc.pseudo_cost_num_up[j] != 0 ? pc.pseudo_cost_sum_up[j] / pc.pseudo_cost_num_up[j]
                                               : pseudo_cost_up_avg;
-    pc.pseudo_cost_mutex[j].unlock();
 
     f_t score_down = std::sqrt(f_up) * (1 + pc_up) / (1 + pc_down);
     f_t score_up   = std::sqrt(f_down) * (1 + pc_down) / (1 + pc_up);
@@ -167,14 +165,12 @@ branch_variable_t<i_t> guided_diving(pseudo_costs_t<i_t, f_t>& pc,
     rounding_direction_t dir =
       down_dist < up_dist + eps ? rounding_direction_t::DOWN : rounding_direction_t::UP;
 
-    pc.pseudo_cost_mutex[j].lock();
     f_t pc_down = pc.pseudo_cost_num_down[j] != 0
                     ? pc.pseudo_cost_sum_down[j] / pc.pseudo_cost_num_down[j]
                     : pseudo_cost_down_avg;
 
     f_t pc_up = pc.pseudo_cost_num_up[j] != 0 ? pc.pseudo_cost_sum_up[j] / pc.pseudo_cost_num_up[j]
                                               : pseudo_cost_up_avg;
-    pc.pseudo_cost_mutex[j].unlock();
 
     f_t score1 = dir == rounding_direction_t::DOWN ? 5 * pc_down * f_down : 5 * pc_up * f_up;
     f_t score2 = dir == rounding_direction_t::DOWN ? pc_up * f_up : pc_down * f_down;

cpp/src/dual_simplex/pseudo_costs.cpp

@@ -270,7 +270,6 @@ template <typename i_t, typename f_t>
 void pseudo_costs_t<i_t, f_t>::update_pseudo_costs(mip_node_t<i_t, f_t>* node_ptr,
                                                    f_t leaf_objective)
 {
-  std::lock_guard<omp_mutex_t> lock(pseudo_cost_mutex[node_ptr->branch_var]);
   const f_t change_in_obj = leaf_objective - node_ptr->lower_bound;
   const f_t frac          = node_ptr->branch_dir == rounding_direction_t::DOWN
                               ? node_ptr->fractional_val - std::floor(node_ptr->fractional_val)
@@ -296,8 +295,6 @@ void pseudo_costs_t<i_t, f_t>::initialized(i_t& num_initialized_down,
   pseudo_cost_up_avg   = 0;
   const i_t n          = pseudo_cost_sum_down.size();
   for (i_t j = 0; j < n; j++) {
-    std::lock_guard<omp_mutex_t> lock(pseudo_cost_mutex[j]);
-
     if (pseudo_cost_num_down[j] > 0) {
       num_initialized_down++;
       if (std::isfinite(pseudo_cost_sum_down[j])) {
@@ -351,7 +348,6 @@ i_t pseudo_costs_t<i_t, f_t>::variable_selection(const std::vector<i_t>& fractio
   for (i_t k = 0; k < num_fractional; k++) {
     const i_t j = fractional[k];
 
-    pseudo_cost_mutex[j].lock();
     if (pseudo_cost_num_down[j] != 0) {
       pseudo_cost_down[k] = pseudo_cost_sum_down[j] / pseudo_cost_num_down[j];
     } else {
@@ -363,7 +359,6 @@ i_t pseudo_costs_t<i_t, f_t>::variable_selection(const std::vector<i_t>& fractio
     } else {
       pseudo_cost_up[k] = pseudo_cost_up_avg;
     }
-    pseudo_cost_mutex[j].unlock();
 
     constexpr f_t eps = 1e-6;
     const f_t f_down  = solution[j] - std::floor(solution[j]);
@@ -444,8 +439,6 @@ i_t pseudo_costs_t<i_t, f_t>::reliable_variable_selection(
   omp_mutex_t score_mutex;
 
   for (auto j : fractional) {
-    std::lock_guard<omp_mutex_t> lock(pseudo_cost_mutex[j]);
-
     if (pseudo_cost_num_down[j] < reliable_threshold ||
         pseudo_cost_num_up[j] < reliable_threshold) {
       unreliable_list.push_back(j);
@@ -599,7 +592,6 @@ f_t pseudo_costs_t<i_t, f_t>::obj_estimate(const std::vector<i_t>& fractional,
     f_t pseudo_cost_down = 0;
     f_t pseudo_cost_up   = 0;
 
-    pseudo_cost_mutex[j].lock();
     if (pseudo_cost_num_down[j] != 0) {
       pseudo_cost_down = pseudo_cost_sum_down[j] / pseudo_cost_num_down[j];
     } else {
@@ -611,7 +603,6 @@ f_t pseudo_costs_t<i_t, f_t>::obj_estimate(const std::vector<i_t>& fractional,
     } else {
       pseudo_cost_up = pseudo_cost_up_avg;
     }
-    pseudo_cost_mutex[j].unlock();
 
     constexpr f_t eps = 1e-6;
     const f_t f_down  = solution[j] - std::floor(solution[j]);

cpp/src/dual_simplex/pseudo_costs.hpp

@@ -69,10 +69,10 @@ class pseudo_costs_t {
 
   void update_pseudo_costs_from_strong_branching(const std::vector<i_t>& fractional,
                                                  const std::vector<f_t>& root_soln);
-  std::vector<f_t> pseudo_cost_sum_up;
-  std::vector<f_t> pseudo_cost_sum_down;
-  std::vector<i_t> pseudo_cost_num_up;
-  std::vector<i_t> pseudo_cost_num_down;
+  std::vector<omp_atomic_t<f_t>> pseudo_cost_sum_up;
+  std::vector<omp_atomic_t<f_t>> pseudo_cost_sum_down;
+  std::vector<omp_atomic_t<i_t>> pseudo_cost_num_up;
+  std::vector<omp_atomic_t<i_t>> pseudo_cost_num_down;
   std::vector<f_t> strong_branch_down;
   std::vector<f_t> strong_branch_up;
   std::vector<omp_mutex_t> pseudo_cost_mutex;