YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// 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.

#ifndef YB_UTIL_UNIQUE_LOCK_H

#define YB_UTIL_UNIQUE_LOCK_H

#include <condition_variable>

#include <mutex>

#include "yb/gutil/thread_annotations.h"

namespace yb {

#if THREAD_ANNOTATIONS_ENABLED

// ------------------------------------------------------------------------------------------------

// Thread annotations enabled, using a UniqueLock wrapper class around std::unique_lock.

// ------------------------------------------------------------------------------------------------

#define UNIQUE_LOCK(lock_name, mutex) ::yb::UniqueLock<decltype(mutex)> lock_name(mutex);

// A wrapper unique_lock that supports thread annotations.

template<typename Mutex>

class SCOPED_CAPABILITY UniqueLock {

 public:

  explicit UniqueLock(Mutex &mutex) ACQUIRE(mutex) : unique_lock_(mutex) {}

_ZN2yb10UniqueLockINS_13percpu_rwlockEEC2ERS1_

Line

Count

Source

35

117

  explicit UniqueLock(Mutex &mutex) ACQUIRE(mutex) : unique_lock_(mutex) {}

_ZN2yb10UniqueLockINSt3__15mutexEEC2ERS2_

Line

Count

Source

35

1.39M

  explicit UniqueLock(Mutex &mutex) ACQUIRE(mutex) : unique_lock_(mutex) {}

_ZN2yb10UniqueLockINSt3__118shared_timed_mutexEEC2ERS2_

Line

Count

Source

35

12

  explicit UniqueLock(Mutex &mutex) ACQUIRE(mutex) : unique_lock_(mutex) {}

  explicit UniqueLock(Mutex &mutex, std::defer_lock_t defer) : unique_lock_(mutex, defer) {}

  ~UniqueLock() RELEASE() = default;

_ZN2yb10UniqueLockINS_13percpu_rwlockEED2Ev

Line

Count

Source

39

117

  ~UniqueLock() RELEASE() = default;

_ZN2yb10UniqueLockINSt3__15mutexEED2Ev

Line

Count

Source

39

1.38M

  ~UniqueLock() RELEASE() = default;

_ZN2yb10UniqueLockINSt3__118shared_timed_mutexEED2Ev

Line

Count

Source

39

12

  ~UniqueLock() RELEASE() = default;

  void unlock() RELEASE() { unique_lock_.unlock(); }

_ZN2yb10UniqueLockINS_13percpu_rwlockEE6unlockEv

Line

Count

Source

41

115

  void unlock() RELEASE() { unique_lock_.unlock(); }

_ZN2yb10UniqueLockINSt3__15mutexEE6unlockEv

Line

Count

Source

41

337k

  void unlock() RELEASE() { unique_lock_.unlock(); }

  void lock() ACQUIRE() { unique_lock_.lock(); }

_ZN2yb10UniqueLockINS_13percpu_rwlockEE4lockEv

Line

Count

Source

42

115

  void lock() ACQUIRE() { unique_lock_.lock(); }

_ZN2yb10UniqueLockINSt3__15mutexEE4lockEv

Line

Count

Source

42

15.1k

  void lock() ACQUIRE() { unique_lock_.lock(); }

  std::unique_lock<Mutex>& internal_unique_lock() { return unique_lock_; }

  Mutex* mutex() RETURN_CAPABILITY(unique_lock_.mutex()) { return unique_lock_.mutex(); }

 private:

  std::unique_lock<Mutex> unique_lock_;

};

template<typename Mutex>

void WaitOnConditionVariable(std::condition_variable* cond_var, UniqueLock<Mutex>* lock)

    REQUIRES(*lock) {

  cond_var->wait(lock->internal_unique_lock());

}

template<typename Mutex, typename Functor>

void WaitOnConditionVariable(

    std::condition_variable* cond_var, UniqueLock<Mutex>* lock, Functor f) {

  cond_var->wait(lock->internal_unique_lock(), f);

}

template <class Mutex>

std::unique_lock<Mutex>& GetLockForCondition(UniqueLock<Mutex>* lock) {

  return lock->internal_unique_lock();

}

#else

// ------------------------------------------------------------------------------------------------

// Thread annotations disabled, no wrapper class needed.

// ------------------------------------------------------------------------------------------------

template<class Mutex>

using UniqueLock = std::unique_lock<Mutex>;

#define UNIQUE_LOCK(lock_name, mutex) std::unique_lock<decltype(mutex)> lock_name(mutex);

template<typename Mutex>

void WaitOnConditionVariable(std::condition_variable* cond_var, UniqueLock<Mutex>* lock) {

  cond_var->wait(*lock);

}

template<typename Mutex, typename Functor>

void WaitOnConditionVariable(

    std::condition_variable* cond_var, UniqueLock<Mutex>* lock, Functor f) {

  cond_var->wait(*lock, f);

}

template <class Mutex>

std::unique_lock<Mutex>& GetLockForCondition(UniqueLock<Mutex>* lock) {

  return *lock;

}

#endif

} // namespace yb

#endif  // YB_UTIL_UNIQUE_LOCK_H