]> git.saurik.com Git - wxWidgets.git/blob - include/wx/atomic.h
Applied #15226 wxRichTextCtrl: Implement setting properties with undo for objects...
[wxWidgets.git] / 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_