← Back to branch summary

~ubuntu-branches/ubuntu/trusty/drizzle/trusty

« back to all changes in this revision

Viewing changes to drizzled/atomic/sun_studio.h

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2010-10-02 14:17:48 UTC
  • mfrom: (1.1.1 upstream)
  • mto: (2.1.17 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20101002141748-m6vbfbfjhrw1153e
Tags: 2010.09.1802-1
* New upstream release.
* Removed pid-file argument hack.
* Updated GPL-2 address to be new address.
* Directly copy in drizzledump.1 since debian doesn't have sphinx 1.0 yet.
* Link to jquery from libjs-jquery. Add it as a depend.
* Add drizzled.8 symlink to the install files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/atomic/sun_studio.h
24
24
#include <atomic.h>
25
25
#undef _KERNEL
26
26
 
 
27
inline bool __sync_fetch_and_add(volatile bool* ptr, bool val)
 
28
{
 
29
  bool ret= *ptr;
 
30
  (val == true) ? atomic_inc_8((volatile uint8_t *)ptr) : atomic_add_8((volatile uint8_t *)ptr, (int8_t)val);
 
31
  return ret;
 
32
}
 
33
 
 
34
inline int8_t __sync_fetch_and_add(volatile int8_t* ptr, int8_t val)
 
35
{
 
36
  int8_t ret= *ptr; 
 
37
  (val == 1) ? atomic_inc_8((volatile uint8_t*)ptr) : atomic_add_8((volatile uint8_t*)ptr, val);
 
38
  return ret;
 
39
}
 
40
 
 
41
inline int16_t __sync_fetch_and_add(volatile int16_t* ptr, int16_t val)
 
42
{
 
43
  int16_t ret= *ptr;
 
44
  (val == 1) ? atomic_inc_16((volatile uint16_t*)ptr) : atomic_add_16((volatile uint16_t*)ptr, val);
 
45
  return ret;
 
46
}
 
47
 
 
48
inline int32_t __sync_fetch_and_add(volatile int32_t* ptr, int32_t val)
 
49
{
 
50
  int32_t ret= *ptr;
 
51
  (val == 1) ? atomic_inc_32((volatile uint32_t*)ptr) : atomic_add_32((volatile uint32_t*)ptr, val);
 
52
  return ret;
 
53
}
 
54
 
 
55
inline uint8_t __sync_fetch_and_add(volatile uint8_t* ptr, uint8_t val)
 
56
{
 
57
  uint8_t ret= *ptr;
 
58
  (val == 1) ? atomic_inc_8(ptr) : atomic_add_8(ptr, (int8_t)val);
 
59
  return ret;
 
60
}
 
61
 
 
62
inline uint16_t __sync_fetch_and_add(volatile uint16_t* ptr, uint16_t val)
 
63
{
 
64
  uint16_t ret= *ptr;
 
65
  (val == 1) ? atomic_inc_16(ptr) : atomic_add_16(ptr, (int16_t)val);
 
66
  return ret;
 
67
}
 
68
 
 
69
inline uint32_t __sync_fetch_and_add(volatile uint32_t* ptr, uint32_t val)
 
70
{
 
71
  uint32_t ret= *ptr;
 
72
  (val == 1) ? atomic_inc_32(ptr) : atomic_add_32(ptr, (int32_t)val);
 
73
  return ret;
 
74
}
 
75
 
 
76
# if defined(_KERNEL) || defined(_INT64_TYPE)
 
77
inline uint64_t __sync_fetch_and_add(volatile uint64_t* ptr, uint64_t val)
 
78
{
 
79
  uint64_t ret= *ptr;
 
80
  (val == 1) ? atomic_inc_64(ptr) : atomic_add_64(ptr, (int64_t)val);
 
81
  return ret;
 
82
}
 
83
 
 
84
inline int64_t __sync_fetch_and_add(volatile int64_t* ptr, int64_t val)
 
85
{
 
86
  int64_t ret= *ptr;
 
87
  (val == 1) ? atomic_inc_64((volatile uint64_t*)ptr) : atomic_add_64((volatile uint64_t*)ptr, val);
 
88
  return ret;
 
89
}
 
90
# endif /* defined(_KERNEL) || defined(_INT64_TYPE) */
 
91
 
 
92
inline uint8_t __sync_fetch_and_sub(volatile uint8_t* ptr, uint8_t val)
 
93
{
 
94
  uint8_t ret= *ptr;
 
95
  (val == 1) ? atomic_dec_8(ptr) : atomic_add_8(ptr, 0-(int8_t)val);
 
96
  return ret;
 
97
}
 
98
 
 
99
inline uint16_t __sync_fetch_and_sub(volatile uint16_t* ptr, uint16_t val)
 
100
{
 
101
  uint16_t ret= *ptr;
 
102
  (val == 1) ? atomic_dec_16(ptr) : atomic_add_16(ptr, 0-(int16_t)val);
 
103
  return ret;
 
104
}
 
105
 
 
106
inline uint32_t __sync_fetch_and_sub(volatile uint32_t* ptr, uint32_t val)
 
107
{
 
108
  uint32_t ret= *ptr;
 
109
  (val == 1) ? atomic_dec_32(ptr) : atomic_add_32(ptr, 0-(int32_t)val);
 
110
  return ret;
 
111
}
 
112
 
 
113
# if defined(_KERNEL) || defined(_INT64_TYPE)
 
114
inline uint64_t __sync_fetch_and_sub(volatile uint64_t* ptr, uint64_t val)
 
115
{
 
116
  uint64_t ret= *ptr;
 
117
  (val == 1) ? atomic_dec_64(ptr) : atomic_add_64(ptr, 0-(int64_t)val);
 
118
  return ret;
 
119
}
 
120
inline int64_t __sync_fetch_and_sub(volatile int64_t* ptr, uint64_t val)
 
121
{
 
122
  int64_t ret= *ptr;
 
123
  (val == 1) ? atomic_dec_64((volatile uint64_t *) ptr) : atomic_add_64((volatile uint64_t *) ptr, 0-(int64_t)val);
 
124
  return ret;
 
125
}
 
126
# endif /* defined(_KERNEL) || defined(_INT64_TYPE) */
 
127
 
27
128
inline bool __sync_add_and_fetch(volatile bool* ptr, bool val)
28
129
{
29
 
  (val == true) ? atomic_inc_8((volatile uint8_t *)ptr) : atomic_add_8((volatile uint8_t *)ptr, (int8_t)val);
30
 
  return *ptr;
 
130
  return (val == true) ? atomic_inc_8_nv((volatile uint8_t *)ptr) : atomic_add_8_nv((volatile uint8_t *)ptr, (int8_t)val);
31
131
}
32
132
 
33
133
inline int8_t __sync_add_and_fetch(volatile int8_t* ptr, int8_t val)
34
134
{
35
 
  (val == 1) ? atomic_inc_8((volatile uint8_t*)ptr) : atomic_add_8((volatile uint8_t*)ptr, val);
36
 
  return *ptr;
 
135
  return (val == 1) ? atomic_inc_8_nv((volatile uint8_t*)ptr) : atomic_add_8_nv((volatile uint8_t*)ptr, val);
37
136
}
38
137
 
39
138
inline int16_t __sync_add_and_fetch(volatile int16_t* ptr, int16_t val)
40
139
{
41
 
  (val == 1) ? atomic_inc_16((volatile uint16_t*)ptr) : atomic_add_16((volatile uint16_t*)ptr, val);
42
 
  return *ptr;
 
140
  return (val == 1) ? atomic_inc_16_nv((volatile uint16_t*)ptr) : atomic_add_16_nv((volatile uint16_t*)ptr, val);
43
141
}
44
142
 
45
143
inline int32_t __sync_add_and_fetch(volatile int32_t* ptr, int32_t val)
46
144
{
47
 
  (val == 1) ? atomic_inc_32((volatile uint32_t*)ptr) : atomic_add_32((volatile uint32_t*)ptr, val);
48
 
  return *ptr;
 
145
  return (val == 1) ? atomic_inc_32_nv((volatile uint32_t*)ptr) : atomic_add_32_nv((volatile uint32_t*)ptr, val);
49
146
}
50
147
 
51
148
inline uint8_t __sync_add_and_fetch(volatile uint8_t* ptr, uint8_t val)
52
149
{
53
 
  (val == 1) ? atomic_inc_8(ptr) : atomic_add_8(ptr, (int8_t)val);
54
 
  return *ptr;
 
150
  return (val == 1) ? atomic_inc_8_nv(ptr) : atomic_add_8_nv(ptr, (int8_t)val);
55
151
}
56
152
 
57
153
inline uint16_t __sync_add_and_fetch(volatile uint16_t* ptr, uint16_t val)
58
154
{
59
 
  (val == 1) ? atomic_inc_16(ptr) : atomic_add_16(ptr, (int16_t)val);
60
 
  return *ptr;
 
155
  return (val == 1) ? atomic_inc_16_nv(ptr) : atomic_add_16_nv(ptr, (int16_t)val);
61
156
}
62
157
 
63
158
inline uint32_t __sync_add_and_fetch(volatile uint32_t* ptr, uint32_t val)
64
159
{
65
 
  (val == 1) ? atomic_inc_32(ptr) : atomic_add_32(ptr, (int32_t)val);
66
 
  return *ptr;
 
160
  return (val == 1) ? atomic_inc_32_nv(ptr) : atomic_add_32_nv(ptr, (int32_t)val);
67
161
}
68
162
 
69
163
# if defined(_KERNEL) || defined(_INT64_TYPE)
70
164
inline uint64_t __sync_add_and_fetch(volatile uint64_t* ptr, uint64_t val)
71
165
{
72
 
  (val == 1) ? atomic_inc_64(ptr) : atomic_add_64(ptr, (int64_t)val);
73
 
  return *ptr;
 
166
  return (val == 1) ? atomic_inc_64_nv(ptr) : atomic_add_64_nv(ptr, (int64_t)val);
74
167
}
75
168
 
76
169
inline int64_t __sync_add_and_fetch(volatile int64_t* ptr, int64_t val)
77
170
{
78
 
  (val == 1) ? atomic_inc_64((volatile uint64_t*)ptr) : atomic_add_64((volatile uint64_t*)ptr, val);
79
 
  return *ptr;
 
171
  return (val == 1) ? atomic_inc_64_nv((volatile uint64_t*)ptr) : atomic_add_64_nv((volatile uint64_t*)ptr, val);
80
172
}
81
173
# endif /* defined(_KERNEL) || defined(_INT64_TYPE) */
82
174
 
83
 
 
84
175
inline uint8_t __sync_sub_and_fetch(volatile uint8_t* ptr, uint8_t val)
85
176
{
86
 
  (val == 1) ? atomic_dec_8(ptr) : atomic_add_8(ptr, 0-(int8_t)val);
87
 
  return *ptr;
 
177
  return (val == 1) ? atomic_dec_8_nv(ptr) : atomic_add_8_nv(ptr, 0-(int8_t)val);
88
178
}
89
179
 
90
180
inline uint16_t __sync_sub_and_fetch(volatile uint16_t* ptr, uint16_t val)
91
181
{
92
 
  (val == 1) ? atomic_dec_16(ptr) : atomic_add_16(ptr, 0-(int16_t)val);
93
 
  return *ptr;
 
182
  return (val == 1) ? atomic_dec_16_nv(ptr) : atomic_add_16_nv(ptr, 0-(int16_t)val);
94
183
}
95
184
 
96
185
inline uint32_t __sync_sub_and_fetch(volatile uint32_t* ptr, uint32_t val)
97
186
{
98
 
  (val == 1) ? atomic_dec_32(ptr) : atomic_add_32(ptr, 0-(int32_t)val);
99
 
  return *ptr;
 
187
  return (val == 1) ? atomic_dec_32_nv(ptr) : atomic_add_32_nv(ptr, 0-(int32_t)val);
100
188
}
101
189
 
102
190
# if defined(_KERNEL) || defined(_INT64_TYPE)
103
191
inline uint64_t __sync_sub_and_fetch(volatile uint64_t* ptr, uint64_t val)
104
192
{
105
 
  (val == 1) ? atomic_dec_64(ptr) : atomic_add_64(ptr, 0-(int64_t)val);
106
 
  return *ptr;
 
193
  return (val == 1) ? atomic_dec_64_nv(ptr) : atomic_add_64_nv(ptr, 0-(int64_t)val);
107
194
}
108
195
inline int64_t __sync_sub_and_fetch(volatile int64_t* ptr, uint64_t val)
109
196
{
110
 
  (val == 1) ? atomic_dec_64((volatile uint64_t *) ptr) : atomic_add_64((volatile uint64_t *) ptr, 0-(int64_t)val);
111
 
  return *ptr;
 
197
  return (val == 1) ? atomic_dec_64_nv((volatile uint64_t *) ptr) : atomic_add_64_nv((volatile uint64_t *) ptr, 0-(int64_t)val);
112
198
}
113
199
# endif /* defined(_KERNEL) || defined(_INT64_TYPE) */
114
200
 
175
261
}
176
262
#endif /* defined(_KERNEL) || defined(_INT64_TYPE) */
177
263
 
 
264
inline int8_t __sync_bool_compare_and_swap(volatile int8_t* ptr,
 
265
                                           int8_t old_val, int8_t val)
 
266
{
 
267
  int8_t orig= *ptr;
 
268
  return orig == atomic_cas_8((volatile uint8_t *)ptr, old_val, val);
 
269
}
 
270
 
 
271
inline uint8_t __sync_bool_compare_and_swap(volatile uint8_t* ptr,
 
272
                                           uint8_t old_val, uint8_t val)
 
273
{
 
274
  uint8_t orig= *ptr;
 
275
  return orig == atomic_cas_8(ptr, old_val, val);
 
276
}
 
277
 
 
278
inline uint16_t __sync_bool_compare_and_swap(volatile uint16_t* ptr,
 
279
                                            uint16_t old_val, uint16_t val)
 
280
{
 
281
  uint16_t orig= *ptr;
 
282
  return orig == atomic_cas_16(ptr, old_val, val);
 
283
}
 
284
 
 
285
inline uint32_t __sync_bool_compare_and_swap(volatile uint32_t* ptr,
 
286
                                            uint32_t old_val, uint32_t val)
 
287
{
 
288
  uint32_t orig= *ptr;
 
289
  return orig == atomic_cas_32(ptr, old_val, val);
 
290
}
 
291
 
 
292
# if defined(_KERNEL) || defined(_INT64_TYPE)
 
293
inline uint64_t __sync_bool_compare_and_swap(volatile uint64_t* ptr,
 
294
                                            uint64_t old_val, uint64_t val)
 
295
{
 
296
  uint64_t orig= *ptr;
 
297
  return orig == atomic_cas_64(ptr, old_val, val);
 
298
}
 
299
#endif /* defined(_KERNEL) || defined(_INT64_TYPE) */
 
300
 
178
301
#endif /* DRIZZLED_ATOMIC_SUN_STUDIO_H */