LCOV - code coverage report
Current view: top level - include/llvm/Support - Mutex.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 14 18 77.8 %
Date: 2017-09-14 15:23:50 Functions: 3 3 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/Support/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_SUPPORT_MUTEX_H
      15             : #define LLVM_SUPPORT_MUTEX_H
      16             : 
      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             :     /// @brief 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             :       /// @brief Default Constructor.
      37             :       explicit MutexImpl(bool recursive = true);
      38             : 
      39             :       /// Releases and removes the lock
      40             :       /// @brief 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             :       /// @brief 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             :       /// @brief 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             :       /// @brief 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      158226 :     class SmartMutex {
      92             :       MutexImpl impl;
      93             :       unsigned acquired;
      94             :       bool recursive;
      95             :     public:
      96      334932 :       explicit SmartMutex(bool rec = true) :
      97      334932 :         impl(rec), acquired(0), recursive(rec) { }
      98             : 
      99      401875 :       bool lock() {
     100      401875 :         if (!mt_only || llvm_is_multithreaded()) {
     101     1473084 :           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           0 :           ++acquired;
     108           0 :           return true;
     109             :         }
     110             :       }
     111             : 
     112      401875 :       bool unlock() {
     113      401875 :         if (!mt_only || llvm_is_multithreaded()) {
     114     1473084 :           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           0 :           --acquired;
     122           0 :           return true;
     123             :         }
     124             :       }
     125             : 
     126             :       bool try_lock() {
     127             :         if (!mt_only || llvm_is_multithreaded())
     128           6 :           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      402858 :       SmartScopedLock(SmartMutex<mt_only>& m) : mtx(m) {
     146      403854 :         mtx.lock();
     147             :       }
     148             : 
     149             :       ~SmartScopedLock() {
     150      403854 :         mtx.unlock();
     151      402858 :       }
     152             :     };
     153             : 
     154             :     typedef SmartScopedLock<false> ScopedLock;
     155             :   }
     156             : }
     157             : 
     158             : #endif

Generated by: LCOV version 1.13