Small refactoring

core/index/index_writer.cpp

@@ -1204,9 +1204,7 @@ void IndexWriter::Clear(uint64_t tick) {
 
   to_commit.ctx = SwitchFlushContext();
   // Ensure there are no active struct update operations
-  std::unique_lock ctx_lock{to_commit.ctx->pending_.Mutex()};
-  to_commit.ctx->pending_.Wait(ctx_lock);
-  ctx_lock.unlock();
+  to_commit.ctx->pending_.Wait();
 
   Abort();  // Abort any already opened transaction
   ApplyFlush(std::move(to_commit));
@@ -1823,11 +1821,8 @@ IndexWriter::PendingContext IndexWriter::PrepareFlush(const CommitInfo& info) {
 
   // noexcept block: I'm not sure is it really necessary or not
   auto ctx = SwitchFlushContext();
-  // TODO(MBkkt) It looks like lock mutex_ completely unnecessary
   // ensure there are no active struct update operations
-  std::unique_lock lock{ctx->pending_.Mutex()};
-  ctx->pending_.Wait(lock);
-  lock.unlock();
+  ctx->pending_.Wait();
   // Stage 0
   // wait for any outstanding segments to settle to ensure that any rollbacks
   // are properly tracked in 'modification_queries_'

core/index/index_writer.hpp

@@ -826,15 +826,14 @@ class IndexWriter : private util::noncopyable {
         }
       }
 
-      void Wait(std::unique_lock<std::mutex>& lock) noexcept {
-        IRS_ASSERT(lock.mutex() == &m_);
-        IRS_ASSERT(lock.owns_lock());
+      void Wait() noexcept {
         if (counter_.fetch_sub(1, std::memory_order_acq_rel) != 1) {
+          std::unique_lock lock{m_};
           do {
             cv_.wait(lock);
-            // relaxed probably enough
           } while (counter_.load(std::memory_order_acquire) != 0);
         }
+        // We can put acquire here and remove above, but is it worth?
         counter_.store(1, std::memory_order_relaxed);
       }