include/llvm/Support/Mutex.h

   1 //===- llvm/Support/Mutex.h - Mutex Operating System Concept -----*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file declares the llvm::sys::Mutex class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_SUPPORT_MUTEX_H
  14 #define LLVM_SUPPORT_MUTEX_H
  15
  16 #include "llvm/Config/llvm-config.h"
  17 #include "llvm/Support/Compiler.h"
  18 #include "llvm/Support/Threading.h"
  19 #include <cassert>
  20
  21 namespace llvm
  22 {
  23   namespace sys
  24   {
  25     /// Platform agnostic Mutex class.
  26     class MutexImpl
  27     {
  28     /// @name Constructors
  29     /// @{
  30     public:
  31
  32       /// Initializes the lock but doesn't acquire it. if \p recursive is set
  33       /// to false, the lock will not be recursive which makes it cheaper but
  34       /// also more likely to deadlock (same thread can't acquire more than
  35       /// once).
  36       /// Default Constructor.
  37       explicit MutexImpl(bool recursive = true);
  38
  39       /// Releases and removes the lock
  40       /// Destructor
  41       ~MutexImpl();
  42
  43     /// @}
  44     /// @name Methods
  45     /// @{
  46     public:
  47
  48       /// Attempts to unconditionally acquire the lock. If the lock is held by
  49       /// another thread, this method will wait until it can acquire the lock.
  50       /// @returns false if any kind of error occurs, true otherwise.
  51       /// Unconditionally acquire the lock.
  52       bool acquire();
  53
  54       /// Attempts to release the lock. If the lock is held by the current
  55       /// thread, the lock is released allowing other threads to acquire the
  56       /// lock.
  57       /// @returns false if any kind of error occurs, true otherwise.
  58       /// Unconditionally release the lock.
  59       bool release();
  60
  61       /// Attempts to acquire the lock without blocking. If the lock is not
  62       /// available, this function returns false quickly (without blocking). If
  63       /// the lock is available, it is acquired.
  64       /// @returns false if any kind of error occurs or the lock is not
  65       /// available, true otherwise.
  66       /// Try to acquire the lock.
  67       bool tryacquire();
  68
  69     //@}
  70     /// @name Platform Dependent Data
  71     /// @{
  72     private:
  73 #if defined(LLVM_ENABLE_THREADS) && LLVM_ENABLE_THREADS != 0
  74       void* data_; ///< We don't know what the data will be
  75 #endif
  76
  77     /// @}
  78     /// @name Do Not Implement
  79     /// @{
  80     private:
  81       MutexImpl(const MutexImpl &) = delete;
  82       void operator=(const MutexImpl &) = delete;
  83     /// @}
  84     };
  85
  86
  87     /// SmartMutex - A mutex with a compile time constant parameter that
  88     /// indicates whether this mutex should become a no-op when we're not
  89     /// running in multithreaded mode.
  90     template<bool mt_only>
  91     class SmartMutex {
  92       MutexImpl impl;
  93       unsigned acquired;
  94       bool recursive;
  95     public:
  96       explicit SmartMutex(bool rec = true) :
  97         impl(rec), acquired(0), recursive(rec) { }
  98
  99       bool lock() {
 100         if (!mt_only || llvm_is_multithreaded()) {
 101           return impl.acquire();
 102         } else {
 103           // Single-threaded debugging code.  This would be racy in
 104           // multithreaded mode, but provides not sanity checks in single
 105           // threaded mode.
 106           assert((recursive || acquired == 0) && "Lock already acquired!!");
 107           ++acquired;
 108           return true;
 109         }
 110       }
 111
 112       bool unlock() {
 113         if (!mt_only || llvm_is_multithreaded()) {
 114           return impl.release();
 115         } else {
 116           // Single-threaded debugging code.  This would be racy in
 117           // multithreaded mode, but provides not sanity checks in single
 118           // threaded mode.
 119           assert(((recursive && acquired) || (acquired == 1)) &&
 120                  "Lock not acquired before release!");
 121           --acquired;
 122           return true;
 123         }
 124       }
 125
 126       bool try_lock() {
 127         if (!mt_only || llvm_is_multithreaded())
 128           return impl.tryacquire();
 129         else return true;
 130       }
 131
 132       private:
 133         SmartMutex(const SmartMutex<mt_only> & original);
 134         void operator=(const SmartMutex<mt_only> &);
 135     };
 136
 137     /// Mutex - A standard, always enforced mutex.
 138     typedef SmartMutex<false> Mutex;
 139
 140     template<bool mt_only>
 141     class SmartScopedLock  {
 142       SmartMutex<mt_only>& mtx;
 143
 144     public:
 145       SmartScopedLock(SmartMutex<mt_only>& m) : mtx(m) {
 146         mtx.lock();
 147       }
 148
 149       ~SmartScopedLock() {
 150         mtx.unlock();
 151       }
 152     };
 153
 154     typedef SmartScopedLock<false> ScopedLock;
 155   }
 156 }
 157
 158 #endif