include/llvm/System/Mutex.h

   1 //===- llvm/System/Mutex.h - Mutex Operating System Concept -----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares the llvm::sys::Mutex class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_SYSTEM_MUTEX_H
  15 #define LLVM_SYSTEM_MUTEX_H
  16
  17 #include "llvm/System/Threading.h"
  18
  19 namespace llvm
  20 {
  21   namespace sys
  22   {
  23     /// @brief Platform agnostic Mutex class.
  24     class MutexImpl
  25     {
  26     /// @name Constructors
  27     /// @{
  28     public:
  29
  30       /// Initializes the lock but doesn't acquire it. if \p recursive is set
  31       /// to false, the lock will not be recursive which makes it cheaper but
  32       /// also more likely to deadlock (same thread can't acquire more than
  33       /// once).
  34       /// @brief Default Constructor.
  35       explicit MutexImpl(bool recursive = true);
  36
  37       /// Releases and removes the lock
  38       /// @brief Destructor
  39       ~MutexImpl();
  40
  41     /// @}
  42     /// @name Methods
  43     /// @{
  44     public:
  45
  46       /// Attempts to unconditionally acquire the lock. If the lock is held by
  47       /// another thread, this method will wait until it can acquire the lock.
  48       /// @returns false if any kind of error occurs, true otherwise.
  49       /// @brief Unconditionally acquire the lock.
  50       bool acquire();
  51
  52       /// Attempts to release the lock. If the lock is held by the current
  53       /// thread, the lock is released allowing other threads to acquire the
  54       /// lock.
  55       /// @returns false if any kind of error occurs, true otherwise.
  56       /// @brief Unconditionally release the lock.
  57       bool release();
  58
  59       /// Attempts to acquire the lock without blocking. If the lock is not
  60       /// available, this function returns false quickly (without blocking). If
  61       /// the lock is available, it is acquired.
  62       /// @returns false if any kind of error occurs or the lock is not
  63       /// available, true otherwise.
  64       /// @brief Try to acquire the lock.
  65       bool tryacquire();
  66
  67     //@}
  68     /// @name Platform Dependent Data
  69     /// @{
  70     private:
  71 #ifdef ENABLE_THREADS
  72       void* data_; ///< We don't know what the data will be
  73 #endif
  74
  75     /// @}
  76     /// @name Do Not Implement
  77     /// @{
  78     private:
  79       MutexImpl(const MutexImpl & original);
  80       void operator=(const MutexImpl &);
  81     /// @}
  82     };
  83
  84
  85     /// SmartMutex - A mutex with a compile time constant parameter that
  86     /// indicates whether this mutex should become a no-op when we're not
  87     /// running in multithreaded mode.
  88     template<bool mt_only>
  89     class SmartMutex : public MutexImpl {
  90     public:
  91       explicit SmartMutex(bool recursive = true) : MutexImpl(recursive) { }
  92
  93       bool acquire() {
  94         if (!mt_only && llvm_is_multithreaded())
  95           return MutexImpl::acquire();
  96         return true;
  97       }
  98
  99       bool release() {
 100         if (!mt_only || llvm_is_multithreaded())
 101           return MutexImpl::release();
 102         return true;
 103       }
 104
 105       bool tryacquire() {
 106         if (!mt_only || llvm_is_multithreaded())
 107           return MutexImpl::tryacquire();
 108         return true;
 109       }
 110
 111       private:
 112         SmartMutex(const SmartMutex<mt_only> & original);
 113         void operator=(const SmartMutex<mt_only> &);
 114     };
 115
 116     /// Mutex - A standard, always enforced mutex.
 117     typedef SmartMutex<false> Mutex;
 118   }
 119 }
 120
 121 #endif