include/wx/atomic.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/atomic.h
   3 // Purpose:     functions to manipulate atomically integers and pointers
   4 // Author:      Armel Asselin
   5 // Created:     12/13/2006
   6 // Copyright:   (c) Armel Asselin
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifndef _WX_ATOMIC_H_
  11 #define _WX_ATOMIC_H_
  12
  13 // ----------------------------------------------------------------------------
  14 // headers
  15 // ----------------------------------------------------------------------------
  16
  17 // get the value of wxUSE_THREADS configuration flag
  18 #include "wx/defs.h"
  19
  20 // constraints on the various functions:
  21 //  - wxAtomicDec must return a zero value if the value is zero once
  22 //  decremented else it must return any non-zero value (the true value is OK
  23 //  but not necessary).
  24
  25 #if wxUSE_THREADS
  26
  27 #if defined(HAVE_GCC_ATOMIC_BUILTINS)
  28
  29 // NB: we intentionally don't use Linux's asm/atomic.h header, because it's
  30 //     an internal kernel header that doesn't always work in userspace:
  31 //     http://bugs.mysql.com/bug.php?id=28456
  32 //     http://golubenco.org/blog/atomic-operations/
  33
  34 inline void wxAtomicInc (wxUint32 &value)
  35 {
  36     __sync_fetch_and_add(&value, 1);
  37 }
  38
  39 inline wxUint32 wxAtomicDec (wxUint32 &value)
  40 {
  41     return __sync_sub_and_fetch(&value, 1);
  42 }
  43
  44
  45 #elif defined(__WINDOWS__)
  46
  47 // include standard Windows headers
  48 #include "wx/msw/wrapwin.h"
  49
  50 inline void wxAtomicInc (wxUint32 &value)
  51 {
  52     InterlockedIncrement ((LONG*)&value);
  53 }
  54
  55 inline wxUint32 wxAtomicDec (wxUint32 &value)
  56 {
  57     return InterlockedDecrement ((LONG*)&value);
  58 }
  59
  60 #elif defined(__WXMAC__) || defined(__DARWIN__)
  61
  62 #include "libkern/OSAtomic.h"
  63 inline void wxAtomicInc (wxUint32 &value)
  64 {
  65     OSAtomicIncrement32 ((int32_t*)&value);
  66 }
  67
  68 inline wxUint32 wxAtomicDec (wxUint32 &value)
  69 {
  70     return OSAtomicDecrement32 ((int32_t*)&value);
  71 }
  72
  73 #elif defined (__SOLARIS__)
  74
  75 #include <atomic.h>
  76
  77 inline void wxAtomicInc (wxUint32 &value)
  78 {
  79     atomic_add_32 ((uint32_t*)&value, 1);
  80 }
  81
  82 inline wxUint32 wxAtomicDec (wxUint32 &value)
  83 {
  84     return atomic_add_32_nv ((uint32_t*)&value, (uint32_t)-1);
  85 }
  86
  87 #else // unknown platform
  88
  89 // it will result in inclusion if the generic implementation code a bit later in this page
  90 #define wxNEEDS_GENERIC_ATOMIC_OPS
  91
  92 #endif // unknown platform
  93
  94 #else // else of wxUSE_THREADS
  95 // if no threads are used we can safely use simple ++/--
  96
  97 inline void wxAtomicInc (wxUint32 &value) { ++value; }
  98 inline wxUint32 wxAtomicDec (wxUint32 &value) { return --value; }
  99
 100 #endif // !wxUSE_THREADS
 101
 102 // ----------------------------------------------------------------------------
 103 // proxies to actual implementations, but for various other types with same
 104 //  behaviour
 105 // ----------------------------------------------------------------------------
 106
 107 #ifdef wxNEEDS_GENERIC_ATOMIC_OPS
 108
 109 #include "wx/thread.h" // for wxCriticalSection
 110
 111 class wxAtomicInt32
 112 {
 113 public:
 114     wxAtomicInt32() { } // non initialized for consistency with basic int type
 115     wxAtomicInt32(wxInt32 v) : m_value(v) { }
 116     wxAtomicInt32(const wxAtomicInt32& a) : m_value(a.m_value) {}
 117
 118     operator wxInt32() const { return m_value; }
 119     operator volatile wxInt32&() { return m_value; }
 120
 121     wxAtomicInt32& operator=(wxInt32 v) { m_value = v; return *this; }
 122
 123     void Inc()
 124     {
 125         wxCriticalSectionLocker lock(m_locker);
 126         ++m_value;
 127     }
 128
 129     wxInt32 Dec()
 130     {
 131         wxCriticalSectionLocker lock(m_locker);
 132         return --m_value;
 133     }
 134
 135 private:
 136     volatile wxInt32  m_value;
 137     wxCriticalSection m_locker;
 138 };
 139
 140 inline void wxAtomicInc(wxAtomicInt32 &value) { value.Inc(); }
 141 inline wxInt32 wxAtomicDec(wxAtomicInt32 &value) { return value.Dec(); }
 142
 143 #else // !wxNEEDS_GENERIC_ATOMIC_OPS
 144
 145 #define wxHAS_ATOMIC_OPS
 146
 147 inline void wxAtomicInc(wxInt32 &value) { wxAtomicInc((wxUint32&)value); }
 148 inline wxInt32 wxAtomicDec(wxInt32 &value) { return wxAtomicDec((wxUint32&)value); }
 149
 150 typedef wxInt32 wxAtomicInt32;
 151
 152 #endif // wxNEEDS_GENERIC_ATOMIC_OPS
 153
 154 // all the native implementations use 32 bits currently
 155 // for a 64 bits implementation we could use (a future) wxAtomicInt64 as
 156 // default type
 157 typedef wxAtomicInt32 wxAtomicInt;
 158
 159 #endif // _WX_ATOMIC_H_