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 {
  90       MutexImpl mtx;
  91     public:
  92       explicit SmartMutex(bool recursive = true) : mtx(recursive) { }
  93
  94       bool acquire() {
  95         if (!mt_only || (mt_only && llvm_is_multithreaded()))
  96           return mtx.acquire();
  97         return true;
  98       }
  99
 100       bool release() {
 101         if (!mt_only || (mt_only && llvm_is_multithreaded()))
 102           return mtx.release();
 103         return true;
 104       }
 105
 106       bool tryacquire() {
 107         if (!mt_only || (mt_only && llvm_is_multithreaded()))
 108           return mtx.tryacquire();
 109         return true;
 110       }
 111
 112       private:
 113         SmartMutex<mt_only>(const SmartMutex<mt_only> & original);
 114         void operator=(const SmartMutex<mt_only> &);
 115     };
 116
 117     /// Mutex - A standard, always enforced mutex.
 118     typedef SmartMutex<false> Mutex;
 119   }
 120 }
 121
 122 #endif