YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.

//  This source code is licensed under the BSD-style license found in the

//  LICENSE file in the root directory of this source tree. An additional grant

//  of patent rights can be found in the PATENTS file in the same directory.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, Inc.

//

// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except

// in compliance with the License.  You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software distributed under the License

// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express

// or implied.  See the License for the specific language governing permissions and limitations

// under the License.

//

// Copyright (c) 2011 The LevelDB Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file. See the AUTHORS file for names of contributors.

#pragma once

#include <atomic>

#include <thread>

#include "yb/rocksdb/port/port.h"

namespace rocksdb {

// Helper class that locks a mutex on construction and unlocks the mutex when

// the destructor of the MutexLock object is invoked.

//

// Typical usage:

//

//   void MyClass::MyMethod() {

//     MutexLock l(&mu_);       // mu_ is an instance variable

//     ... some complex code, possibly with multiple return paths ...

//   }

class MutexLock {

 public:

  explicit MutexLock(port::Mutex *mu) : mu_(mu) {

    this->mu_->Lock();

  }

  ~MutexLock() { this->mu_->Unlock(); }

 private:

  port::Mutex *const mu_;

  // No copying allowed

  MutexLock(const MutexLock&);

  void operator=(const MutexLock&);

};

//

// Acquire a ReadLock on the specified RWMutex.

// The Lock will be automatically released then the

// object goes out of scope.

//

class ReadLock {

 public:

  explicit ReadLock(port::RWMutex *mu) : mu_(mu) {

    this->mu_->ReadLock();

  }

  ~ReadLock() { this->mu_->ReadUnlock(); }

 private:

  port::RWMutex *const mu_;

  // No copying allowed

  ReadLock(const ReadLock&);

  void operator=(const ReadLock&);

};

//

// Acquire a WriteLock on the specified RWMutex.

// The Lock will be automatically released then the

// object goes out of scope.

//

class WriteLock {

 public:

  explicit WriteLock(port::RWMutex *mu) : mu_(mu) {

    this->mu_->WriteLock();

  }

  ~WriteLock() { this->mu_->WriteUnlock(); }

 private:

  port::RWMutex *const mu_;

  // No copying allowed

  WriteLock(const WriteLock&);

  void operator=(const WriteLock&);

};

//

// SpinMutex has very low overhead for low-contention cases.  Method names

// are chosen so you can use std::unique_lock or std::lock_guard with it.

//

class SpinMutex {

 public:

  SpinMutex() : locked_(false) {}

  bool try_lock() {

    auto currently_locked = locked_.load(std::memory_order_relaxed);

    return !currently_locked &&

           locked_.compare_exchange_weak(currently_locked, true,

                                         std::memory_order_acquire,

                                         std::memory_order_relaxed);

  }

  void lock() {

    for (size_t tries = 0;; ++tries) {

      if (try_lock()) {

        // success

        break;

      }

      port::AsmVolatilePause();

      if (tries > 100) {

        std::this_thread::yield();

      }

    }

  }

  void unlock() { locked_.store(false, std::memory_order_release); }

 private:

  std::atomic<bool> locked_;

};

}  // namespace rocksdb