ortools: use new MutexLock ctor

Author: Mizux

ortools/lp_data/lp_decomposer.cc

@@ -36,7 +36,7 @@ LPDecomposer::LPDecomposer()
     : original_problem_(nullptr), clusters_(), mutex_() {}
 
 void LPDecomposer::Decompose(const LinearProgram* linear_problem) {
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   original_problem_ = linear_problem;
   clusters_.clear();
 
@@ -69,12 +69,12 @@ void LPDecomposer::Decompose(const LinearProgram* linear_problem) {
 }
 
 int LPDecomposer::GetNumberOfProblems() const {
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   return clusters_.size();
 }
 
 const LinearProgram& LPDecomposer::original_problem() const {
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   return *original_problem_;
 }
 
@@ -85,7 +85,7 @@ void LPDecomposer::ExtractLocalProblem(int problem_index, LinearProgram* lp) {
 
   lp->Clear();
 
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   const std::vector<ColIndex>& cluster = clusters_[problem_index];
   StrictITIVector<ColIndex, ColIndex> global_to_local(
       original_problem_->num_variables(), kInvalidCol);
@@ -143,7 +143,7 @@ DenseRow LPDecomposer::AggregateAssignments(
     absl::Span<const DenseRow> assignments) const {
   CHECK_EQ(assignments.size(), clusters_.size());
 
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   DenseRow global_assignment(original_problem_->num_variables(),
                              Fractional(0.0));
   for (int problem = 0; problem < assignments.size(); ++problem) {
@@ -163,7 +163,7 @@ DenseRow LPDecomposer::ExtractLocalAssignment(int problem_index,
   CHECK_LT(problem_index, clusters_.size());
   CHECK_EQ(assignment.size(), original_problem_->num_variables());
 
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   const std::vector<ColIndex>& cluster = clusters_[problem_index];
   DenseRow local_assignment(ColIndex(cluster.size()), Fractional(0.0));
   for (int i = 0; i < cluster.size(); ++i) {

ortools/util/solve_interrupter.cc

@@ -25,7 +25,7 @@
 namespace operations_research {
 
 void SolveInterrupter::Interrupt() {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
 
   // Here we don't use compare_exchange_strong since we need to hold the lock
   // before changing the value of interrupted_ anyway. So there is no need to
@@ -51,7 +51,7 @@ void SolveInterrupter::Interrupt() {
 
 SolveInterrupter::CallbackId SolveInterrupter::AddInterruptionCallback(
     Callback callback) const {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
 
   // We must make this call while holding the lock since we want to be sure that
   // the calls to the callbacks_ won't occur before we registered the new
@@ -72,7 +72,7 @@ SolveInterrupter::CallbackId SolveInterrupter::AddInterruptionCallback(
 }
 
 void SolveInterrupter::RemoveInterruptionCallback(CallbackId id) const {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
   CHECK_EQ(callbacks_.erase(id), 1) << "unregistered callback id: " << id;
 }
 

ortools/util/time_limit.h

@@ -343,37 +343,37 @@ class SharedTimeLimit {
   bool LimitReached() const {
     // Note, time_limit_->LimitReached() is not const, and changes internal
     // state of time_limit_, hence we need a writer's lock.
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     return time_limit_->LimitReached();
   }
 
   void Stop() {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     *stopped_ = true;
   }
 
   void UpdateLocalLimit(TimeLimit* local_limit) {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     local_limit->MergeWithGlobalTimeLimit(time_limit_);
   }
 
   void AdvanceDeterministicTime(double deterministic_duration) {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     time_limit_->AdvanceDeterministicTime(deterministic_duration);
   }
 
   double GetTimeLeft() const {
-    absl::ReaderMutexLock lock(&mutex_);
+    absl::ReaderMutexLock lock(mutex_);
     return time_limit_->GetTimeLeft();
   }
 
   double GetElapsedDeterministicTime() const {
-    absl::ReaderMutexLock lock(&mutex_);
+    absl::ReaderMutexLock lock(mutex_);
     return time_limit_->GetElapsedDeterministicTime();
   }
 
   std::atomic<bool>* ExternalBooleanAsLimit() const {
-    absl::ReaderMutexLock lock(&mutex_);
+    absl::ReaderMutexLock lock(mutex_);
     // We can simply return the "external bool" and remain thread-safe because
     // it's wrapped in std::atomic.
     return time_limit_->ExternalBooleanAsLimit();