lock_order.h

Go to the documentation of this file.

 
#pragma once
 
#include <mutex>
#include <shared_mutex>
 
#include <rex/platform.h>
#include <rex/types.h>
#include <rex/utility.h>
 
namespace rex::platform {

enum class LockRank : u8 {
  kLeaf = 0xFF, 
};

using LockOrderHandler = void (*)(LockRank held, LockRank acquiring);

REX_API LockOrderHandler SetLockOrderHandler(LockOrderHandler handler);

REX_API void PushLockRank(LockRank rank);
 
REX_API void PopLockRank(LockRank rank);

class RankedMutex : public rex::NonCopyable {
 public:
  explicit RankedMutex(LockRank rank) : rank_(rank) {}
 
  void lock() {
    PushLockRank(rank_);
    mutex_.lock();
  }
 
  bool try_lock() {
    if (!mutex_.try_lock()) {
      return false;
    }
    PushLockRank(rank_);
    return true;
  }
 
  void unlock() {
    PopLockRank(rank_);
    mutex_.unlock();
  }
 
 private:
  std::mutex mutex_;
  LockRank rank_;
};

class RankedSharedMutex : public rex::NonCopyable {
 public:
  explicit RankedSharedMutex(LockRank rank) : rank_(rank) {}
 
  void lock() {
    PushLockRank(rank_);
    mutex_.lock();
  }
 
  void unlock() {
    PopLockRank(rank_);
    mutex_.unlock();
  }
 
  void lock_shared() {
    PushLockRank(rank_);
    mutex_.lock_shared();
  }
 
  void unlock_shared() {
    PopLockRank(rank_);
    mutex_.unlock_shared();
  }
 
 private:
  std::shared_mutex mutex_;
  LockRank rank_;
};
 
}  // namespace rex::platform
 
namespace rex::platform::lock_rank {

inline constexpr LockRank kInterruptState{1};

inline constexpr LockRank kObjectIdentityMap{2};

inline constexpr LockRank kObjectTable{3};

inline constexpr LockRank kObjectNameMap{4};

inline constexpr LockRank kThreadRegistry{5};

inline constexpr LockRank kModuleRegistry{6};

inline constexpr LockRank kObjectState{7};

inline constexpr LockRank kDPC{8};
 
}  // namespace rex::platform::lock_rank