contrib/llvm/include/llvm/Support/RWMutex.h

   1 //===- RWMutex.h - Reader/Writer Mutual Exclusion Lock ----------*- 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::RWMutex class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_SYSTEM_RWMUTEX_H
  15 #define LLVM_SYSTEM_RWMUTEX_H
  16
  17 #include "llvm/Support/Threading.h"
  18 #include <cassert>
  19
  20 namespace llvm
  21 {
  22   namespace sys
  23   {
  24     /// @brief Platform agnostic RWMutex class.
  25     class RWMutexImpl
  26     {
  27     /// @name Constructors
  28     /// @{
  29     public:
  30
  31       /// Initializes the lock but doesn't acquire it.
  32       /// @brief Default Constructor.
  33       explicit RWMutexImpl();
  34
  35       /// Releases and removes the lock
  36       /// @brief Destructor
  37       ~RWMutexImpl();
  38
  39     /// @}
  40     /// @name Methods
  41     /// @{
  42     public:
  43
  44       /// Attempts to unconditionally acquire the lock in reader mode. If the
  45       /// lock is held by a writer, this method will wait until it can acquire
  46       /// the lock.
  47       /// @returns false if any kind of error occurs, true otherwise.
  48       /// @brief Unconditionally acquire the lock in reader mode.
  49       bool reader_acquire();
  50
  51       /// Attempts to release the lock in reader mode.
  52       /// @returns false if any kind of error occurs, true otherwise.
  53       /// @brief Unconditionally release the lock in reader mode.
  54       bool reader_release();
  55
  56       /// Attempts to unconditionally acquire the lock in reader mode. If the
  57       /// lock is held by any readers, this method will wait until it can
  58       /// acquire the lock.
  59       /// @returns false if any kind of error occurs, true otherwise.
  60       /// @brief Unconditionally acquire the lock in writer mode.
  61       bool writer_acquire();
  62
  63       /// Attempts to release the lock in writer mode.
  64       /// @returns false if any kind of error occurs, true otherwise.
  65       /// @brief Unconditionally release the lock in write mode.
  66       bool writer_release();
  67
  68     //@}
  69     /// @name Platform Dependent Data
  70     /// @{
  71     private:
  72       void* data_; ///< We don't know what the data will be
  73
  74     /// @}
  75     /// @name Do Not Implement
  76     /// @{
  77     private:
  78       RWMutexImpl(const RWMutexImpl & original);
  79       void operator=(const RWMutexImpl &);
  80     /// @}
  81     };
  82
  83     /// SmartMutex - An R/W mutex with a compile time constant parameter that
  84     /// indicates whether this mutex should become a no-op when we're not
  85     /// running in multithreaded mode.
  86     template<bool mt_only>
  87     class SmartRWMutex : public RWMutexImpl {
  88       unsigned readers, writers;
  89     public:
  90       explicit SmartRWMutex() : RWMutexImpl(), readers(0), writers(0) { }
  91
  92       bool reader_acquire() {
  93         if (!mt_only || llvm_is_multithreaded())
  94           return RWMutexImpl::reader_acquire();
  95
  96         // Single-threaded debugging code.  This would be racy in multithreaded
  97         // mode, but provides not sanity checks in single threaded mode.
  98         ++readers;
  99         return true;
 100       }
 101
 102       bool reader_release() {
 103         if (!mt_only || llvm_is_multithreaded())
 104           return RWMutexImpl::reader_release();
 105
 106         // Single-threaded debugging code.  This would be racy in multithreaded
 107         // mode, but provides not sanity checks in single threaded mode.
 108         assert(readers > 0 && "Reader lock not acquired before release!");
 109         --readers;
 110         return true;
 111       }
 112
 113       bool writer_acquire() {
 114         if (!mt_only || llvm_is_multithreaded())
 115           return RWMutexImpl::writer_acquire();
 116
 117         // Single-threaded debugging code.  This would be racy in multithreaded
 118         // mode, but provides not sanity checks in single threaded mode.
 119         assert(writers == 0 && "Writer lock already acquired!");
 120         ++writers;
 121         return true;
 122       }
 123
 124       bool writer_release() {
 125         if (!mt_only || llvm_is_multithreaded())
 126           return RWMutexImpl::writer_release();
 127
 128         // Single-threaded debugging code.  This would be racy in multithreaded
 129         // mode, but provides not sanity checks in single threaded mode.
 130         assert(writers == 1 && "Writer lock not acquired before release!");
 131         --writers;
 132         return true;
 133       }
 134
 135     private:
 136       SmartRWMutex(const SmartRWMutex<mt_only> & original);
 137       void operator=(const SmartRWMutex<mt_only> &);
 138     };
 139     typedef SmartRWMutex<false> RWMutex;
 140
 141     /// ScopedReader - RAII acquisition of a reader lock
 142     template<bool mt_only>
 143     struct SmartScopedReader {
 144       SmartRWMutex<mt_only>& mutex;
 145
 146       explicit SmartScopedReader(SmartRWMutex<mt_only>& m) : mutex(m) {
 147         mutex.reader_acquire();
 148       }
 149
 150       ~SmartScopedReader() {
 151         mutex.reader_release();
 152       }
 153     };
 154     typedef SmartScopedReader<false> ScopedReader;
 155
 156     /// ScopedWriter - RAII acquisition of a writer lock
 157     template<bool mt_only>
 158     struct SmartScopedWriter {
 159       SmartRWMutex<mt_only>& mutex;
 160
 161       explicit SmartScopedWriter(SmartRWMutex<mt_only>& m) : mutex(m) {
 162         mutex.writer_acquire();
 163       }
 164
 165       ~SmartScopedWriter() {
 166         mutex.writer_release();
 167       }
 168     };
 169     typedef SmartScopedWriter<false> ScopedWriter;
 170   }
 171 }
 172
 173 #endif