← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/clamav/jaunty-backports

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/System/Mutex.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (1.39.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 11.
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/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
#include <cassert>
 
19
 
 
20
namespace llvm
 
21
{
 
22
  namespace sys
 
23
  {
 
24
    /// @brief Platform agnostic Mutex class.
 
25
    class MutexImpl
 
26
    {
 
27
    /// @name Constructors
 
28
    /// @{
 
29
    public:
 
30
 
 
31
      /// Initializes the lock but doesn't acquire it. if \p recursive is set
 
32
      /// to false, the lock will not be recursive which makes it cheaper but
 
33
      /// also more likely to deadlock (same thread can't acquire more than
 
34
      /// once).
 
35
      /// @brief Default Constructor.
 
36
      explicit MutexImpl(bool recursive = true);
 
37
 
 
38
      /// Releases and removes the lock
 
39
      /// @brief Destructor
 
40
      ~MutexImpl();
 
41
 
 
42
    /// @}
 
43
    /// @name Methods
 
44
    /// @{
 
45
    public:
 
46
 
 
47
      /// Attempts to unconditionally acquire the lock. If the lock is held by
 
48
      /// another thread, this method will wait until it can acquire the lock.
 
49
      /// @returns false if any kind of error occurs, true otherwise.
 
50
      /// @brief Unconditionally acquire the lock.
 
51
      bool acquire();
 
52
 
 
53
      /// Attempts to release the lock. If the lock is held by the current
 
54
      /// thread, the lock is released allowing other threads to acquire the
 
55
      /// lock.
 
56
      /// @returns false if any kind of error occurs, true otherwise.
 
57
      /// @brief Unconditionally release the lock.
 
58
      bool release();
 
59
 
 
60
      /// Attempts to acquire the lock without blocking. If the lock is not
 
61
      /// available, this function returns false quickly (without blocking). If
 
62
      /// the lock is available, it is acquired.
 
63
      /// @returns false if any kind of error occurs or the lock is not
 
64
      /// available, true otherwise.
 
65
      /// @brief Try to acquire the lock.
 
66
      bool tryacquire();
 
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
      MutexImpl(const MutexImpl & original);
 
79
      void operator=(const MutexImpl &);
 
80
    /// @}
 
81
    };
 
82
    
 
83
    
 
84
    /// SmartMutex - A mutex with a compile time constant parameter that 
 
85
    /// indicates whether this mutex should become a no-op when we're not
 
86
    /// running in multithreaded mode.
 
87
    template<bool mt_only>
 
88
    class SmartMutex : public MutexImpl {
 
89
      unsigned acquired;
 
90
      bool recursive;
 
91
    public:
 
92
      explicit SmartMutex(bool rec = true) :
 
93
        MutexImpl(rec), acquired(0), recursive(rec) { }
 
94
      
 
95
      bool acquire() {
 
96
        if (!mt_only || llvm_is_multithreaded()) {
 
97
          return MutexImpl::acquire();
 
98
        } else {
 
99
          // Single-threaded debugging code.  This would be racy in
 
100
          // multithreaded mode, but provides not sanity checks in single
 
101
          // threaded mode.
 
102
          assert((recursive || acquired == 0) && "Lock already acquired!!");
 
103
          ++acquired;
 
104
          return true;
 
105
        }
 
106
      }
 
107
 
 
108
      bool release() {
 
109
        if (!mt_only || llvm_is_multithreaded()) {
 
110
          return MutexImpl::release();
 
111
        } else {
 
112
          // Single-threaded debugging code.  This would be racy in
 
113
          // multithreaded mode, but provides not sanity checks in single
 
114
          // threaded mode.
 
115
          assert(((recursive && acquired) || (acquired == 1)) &&
 
116
                 "Lock not acquired before release!");
 
117
          --acquired;
 
118
          return true;
 
119
        }
 
120
      }
 
121
 
 
122
      bool tryacquire() {
 
123
        if (!mt_only || llvm_is_multithreaded())
 
124
          return MutexImpl::tryacquire();
 
125
        else return true;
 
126
      }
 
127
      
 
128
      private:
 
129
        SmartMutex(const SmartMutex<mt_only> & original);
 
130
        void operator=(const SmartMutex<mt_only> &);
 
131
    };
 
132
    
 
133
    /// Mutex - A standard, always enforced mutex.
 
134
    typedef SmartMutex<false> Mutex;
 
135
    
 
136
    template<bool mt_only>
 
137
    class SmartScopedLock  {
 
138
      SmartMutex<mt_only>& mtx;
 
139
      
 
140
    public:
 
141
      SmartScopedLock(SmartMutex<mt_only>& m) : mtx(m) {
 
142
        mtx.acquire();
 
143
      }
 
144
      
 
145
      ~SmartScopedLock() {
 
146
        mtx.release();
 
147
      }
 
148
    };
 
149
    
 
150
    typedef SmartScopedLock<false> ScopedLock;
 
151
  }
 
152
}
 
153
 
 
154
#endif