← Back to branch summary

~ubuntu-branches/ubuntu/wily/ruby-passenger/wily-proposed

« back to all changes in this revision

Viewing changes to ext/boost/atomic/detail/cas64strong.hpp

  • Committer: Package Import Robot
  • Author(s): Felix Geyer
  • Date: 2013-11-23 23:50:02 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20131123235002-8fdhsq7afj15o2z2
Tags: 4.0.25-1
http://bugs.debian.org/725591
* New upstream release.
* Refresh fix_install_path.patch.
* Build for Ruby 2.0 instead of 1.8. (Closes: #725591)
* Add fix_ftbfs_fortify_source.patch.
* Install passenger template files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/boost/atomic/detail/cas64strong.hpp
 
1
#ifndef BOOST_ATOMIC_DETAIL_CAS64STRONG_HPP
 
2
#define BOOST_ATOMIC_DETAIL_CAS64STRONG_HPP
 
3
 
 
4
//  Distributed under the Boost Software License, Version 1.0.
 
5
//  See accompanying file LICENSE_1_0.txt or copy at
 
6
//  http://www.boost.org/LICENSE_1_0.txt)
 
7
//
 
8
//  Copyright (c) 2011 Helge Bahmann
 
9
//  Copyright (c) 2013 Tim Blechmann
 
10
 
 
11
// Build 64-bit atomic operation from platform_cmpxchg64_strong
 
12
// primitive. It is assumed that 64-bit loads/stores are not
 
13
// atomic, so they are funnelled through cmpxchg as well.
 
14
 
 
15
#include <cstddef>
 
16
#include <boost/cstdint.hpp>
 
17
#include <boost/memory_order.hpp>
 
18
#include <boost/atomic/detail/config.hpp>
 
19
#include <boost/atomic/detail/base.hpp>
 
20
 
 
21
#ifdef BOOST_ATOMIC_HAS_PRAGMA_ONCE
 
22
#pragma once
 
23
#endif
 
24
 
 
25
namespace boost {
 
26
namespace atomics {
 
27
namespace detail {
 
28
 
 
29
/* integral types */
 
30
 
 
31
template<typename T, bool Sign>
 
32
class base_atomic<T, int, 8, Sign>
 
33
{
 
34
    typedef base_atomic this_type;
 
35
    typedef T value_type;
 
36
    typedef T difference_type;
 
37
public:
 
38
    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
 
39
    base_atomic(void) {}
 
40
 
 
41
    void
 
42
    store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
43
    {
 
44
        platform_fence_before_store(order);
 
45
        platform_store64(v, &v_);
 
46
        platform_fence_after_store(order);
 
47
    }
 
48
 
 
49
    value_type
 
50
    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
 
51
    {
 
52
        value_type v = platform_load64(&v_);
 
53
        platform_fence_after_load(order);
 
54
        return v;
 
55
    }
 
56
 
 
57
    value_type
 
58
    exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
59
    {
 
60
        value_type original = load(memory_order_relaxed);
 
61
        do {
 
62
        } while (!compare_exchange_weak(original, v, order, memory_order_relaxed));
 
63
        return original;
 
64
    }
 
65
 
 
66
    bool
 
67
    compare_exchange_weak(
 
68
        value_type & expected,
 
69
        value_type desired,
 
70
        memory_order success_order,
 
71
        memory_order failure_order) volatile BOOST_NOEXCEPT
 
72
    {
 
73
        return compare_exchange_strong(expected, desired, success_order, failure_order);
 
74
    }
 
75
 
 
76
    bool
 
77
    compare_exchange_strong(
 
78
        value_type & expected,
 
79
        value_type desired,
 
80
        memory_order success_order,
 
81
        memory_order failure_order) volatile BOOST_NOEXCEPT
 
82
    {
 
83
        platform_fence_before(success_order);
 
84
 
 
85
        bool success = platform_cmpxchg64_strong(expected, desired, &v_);
 
86
 
 
87
        if (success) {
 
88
            platform_fence_after(success_order);
 
89
        } else {
 
90
            platform_fence_after(failure_order);
 
91
        }
 
92
 
 
93
        return success;
 
94
    }
 
95
 
 
96
    value_type
 
97
    fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
98
    {
 
99
        value_type original = load(memory_order_relaxed);
 
100
        do {
 
101
        } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed));
 
102
        return original;
 
103
    }
 
104
 
 
105
    value_type
 
106
    fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
107
    {
 
108
        value_type original = load(memory_order_relaxed);
 
109
        do {
 
110
        } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed));
 
111
        return original;
 
112
    }
 
113
 
 
114
    value_type
 
115
    fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
116
    {
 
117
        value_type original = load(memory_order_relaxed);
 
118
        do {
 
119
        } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed));
 
120
        return original;
 
121
    }
 
122
 
 
123
    value_type
 
124
    fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
125
    {
 
126
        value_type original = load(memory_order_relaxed);
 
127
        do {
 
128
        } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed));
 
129
        return original;
 
130
    }
 
131
 
 
132
    value_type
 
133
    fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
134
    {
 
135
        value_type original = load(memory_order_relaxed);
 
136
        do {
 
137
        } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed));
 
138
        return original;
 
139
    }
 
140
 
 
141
    bool
 
142
    is_lock_free(void) const volatile BOOST_NOEXCEPT
 
143
    {
 
144
        return true;
 
145
    }
 
146
 
 
147
    BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS
 
148
private:
 
149
    base_atomic(const base_atomic &) /* = delete */ ;
 
150
    void operator=(const base_atomic &) /* = delete */ ;
 
151
    value_type v_;
 
152
};
 
153
 
 
154
/* pointer types */
 
155
 
 
156
template<bool Sign>
 
157
class base_atomic<void *, void *, 8, Sign>
 
158
{
 
159
    typedef base_atomic this_type;
 
160
    typedef void * value_type;
 
161
    typedef ptrdiff_t difference_type;
 
162
public:
 
163
    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
 
164
    base_atomic(void) {}
 
165
 
 
166
    void
 
167
    store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
168
    {
 
169
        platform_fence_before_store(order);
 
170
        platform_store64(v, &v_);
 
171
        platform_fence_after_store(order);
 
172
    }
 
173
 
 
174
    value_type
 
175
    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
 
176
    {
 
177
        value_type v = platform_load64(&v_);
 
178
        platform_fence_after_load(order);
 
179
        return v;
 
180
    }
 
181
 
 
182
    value_type
 
183
    exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
184
    {
 
185
        value_type original = load(memory_order_relaxed);
 
186
        do {
 
187
        } while (!compare_exchange_weak(original, v, order, memory_order_relaxed));
 
188
        return original;
 
189
    }
 
190
 
 
191
    bool
 
192
    compare_exchange_weak(
 
193
        value_type & expected,
 
194
        value_type desired,
 
195
        memory_order success_order,
 
196
        memory_order failure_order) volatile BOOST_NOEXCEPT
 
197
    {
 
198
        return compare_exchange_strong(expected, desired, success_order, failure_order);
 
199
    }
 
200
 
 
201
    bool
 
202
    compare_exchange_strong(
 
203
        value_type & expected,
 
204
        value_type desired,
 
205
        memory_order success_order,
 
206
        memory_order failure_order) volatile BOOST_NOEXCEPT
 
207
    {
 
208
        platform_fence_before(success_order);
 
209
 
 
210
        bool success = platform_cmpxchg64_strong(expected, desired, &v_);
 
211
 
 
212
        if (success) {
 
213
            platform_fence_after(success_order);
 
214
        } else {
 
215
            platform_fence_after(failure_order);
 
216
        }
 
217
 
 
218
        return success;
 
219
    }
 
220
 
 
221
    value_type
 
222
    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
223
    {
 
224
        value_type original = load(memory_order_relaxed);
 
225
        do {
 
226
        } while (!compare_exchange_weak(original, (char*)original + v, order, memory_order_relaxed));
 
227
        return original;
 
228
    }
 
229
 
 
230
    value_type
 
231
    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
232
    {
 
233
        value_type original = load(memory_order_relaxed);
 
234
        do {
 
235
        } while (!compare_exchange_weak(original, (char*)original - v, order, memory_order_relaxed));
 
236
        return original;
 
237
    }
 
238
 
 
239
    bool
 
240
    is_lock_free(void) const volatile BOOST_NOEXCEPT
 
241
    {
 
242
        return true;
 
243
    }
 
244
 
 
245
    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
 
246
private:
 
247
    base_atomic(const base_atomic &) /* = delete */ ;
 
248
    void operator=(const base_atomic &) /* = delete */ ;
 
249
    value_type v_;
 
250
};
 
251
 
 
252
template<typename T, bool Sign>
 
253
class base_atomic<T *, void *, 8, Sign>
 
254
{
 
255
    typedef base_atomic this_type;
 
256
    typedef T * value_type;
 
257
    typedef ptrdiff_t difference_type;
 
258
public:
 
259
    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
 
260
    base_atomic(void) {}
 
261
 
 
262
    void
 
263
    store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
264
    {
 
265
        platform_fence_before_store(order);
 
266
        platform_store64(v, &v_);
 
267
        platform_fence_after_store(order);
 
268
    }
 
269
 
 
270
    value_type
 
271
    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
 
272
    {
 
273
        value_type v = platform_load64(&v_);
 
274
        platform_fence_after_load(order);
 
275
        return v;
 
276
    }
 
277
 
 
278
    value_type
 
279
    exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
280
    {
 
281
        value_type original = load(memory_order_relaxed);
 
282
        do {
 
283
        } while (!compare_exchange_weak(original, v, order, memory_order_relaxed));
 
284
        return original;
 
285
    }
 
286
 
 
287
    bool
 
288
    compare_exchange_weak(
 
289
        value_type & expected,
 
290
        value_type desired,
 
291
        memory_order success_order,
 
292
        memory_order failure_order) volatile BOOST_NOEXCEPT
 
293
    {
 
294
        return compare_exchange_strong(expected, desired, success_order, failure_order);
 
295
    }
 
296
 
 
297
    bool
 
298
    compare_exchange_strong(
 
299
        value_type & expected,
 
300
        value_type desired,
 
301
        memory_order success_order,
 
302
        memory_order failure_order) volatile BOOST_NOEXCEPT
 
303
    {
 
304
        platform_fence_before(success_order);
 
305
 
 
306
        bool success = platform_cmpxchg64_strong(expected, desired, &v_);
 
307
 
 
308
        if (success) {
 
309
            platform_fence_after(success_order);
 
310
        } else {
 
311
            platform_fence_after(failure_order);
 
312
        }
 
313
 
 
314
        return success;
 
315
    }
 
316
 
 
317
    value_type
 
318
    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
319
    {
 
320
        value_type original = load(memory_order_relaxed);
 
321
        do {
 
322
        } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed));
 
323
        return original;
 
324
    }
 
325
 
 
326
    value_type
 
327
    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
328
    {
 
329
        value_type original = load(memory_order_relaxed);
 
330
        do {
 
331
        } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed));
 
332
        return original;
 
333
    }
 
334
 
 
335
    bool
 
336
    is_lock_free(void) const volatile BOOST_NOEXCEPT
 
337
    {
 
338
        return true;
 
339
    }
 
340
 
 
341
    BOOST_ATOMIC_DECLARE_POINTER_OPERATORS
 
342
private:
 
343
    base_atomic(const base_atomic &) /* = delete */ ;
 
344
    void operator=(const base_atomic &) /* = delete */ ;
 
345
    value_type v_;
 
346
};
 
347
 
 
348
/* generic types */
 
349
 
 
350
template<typename T, bool Sign>
 
351
class base_atomic<T, void, 8, Sign>
 
352
{
 
353
    typedef base_atomic this_type;
 
354
    typedef T value_type;
 
355
    typedef uint64_t storage_type;
 
356
public:
 
357
    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
 
358
    {
 
359
        memcpy(&v_, &v, sizeof(value_type));
 
360
    }
 
361
    base_atomic(void) {}
 
362
 
 
363
    void
 
364
    store(value_type const& value, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
365
    {
 
366
        storage_type value_s = 0;
 
367
        memcpy(&value_s, &value, sizeof(value_type));
 
368
        platform_fence_before_store(order);
 
369
        platform_store64(value_s, &v_);
 
370
        platform_fence_after_store(order);
 
371
    }
 
372
 
 
373
    value_type
 
374
    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
 
375
    {
 
376
        storage_type value_s = platform_load64(&v_);
 
377
        platform_fence_after_load(order);
 
378
        value_type value;
 
379
        memcpy(&value, &value_s, sizeof(value_type));
 
380
        return value;
 
381
    }
 
382
 
 
383
    value_type
 
384
    exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
 
385
    {
 
386
        value_type original = load(memory_order_relaxed);
 
387
        do {
 
388
        } while (!compare_exchange_weak(original, v, order, memory_order_relaxed));
 
389
        return original;
 
390
    }
 
391
 
 
392
    bool
 
393
    compare_exchange_weak(
 
394
        value_type & expected,
 
395
        value_type const& desired,
 
396
        memory_order success_order,
 
397
        memory_order failure_order) volatile BOOST_NOEXCEPT
 
398
    {
 
399
        return compare_exchange_strong(expected, desired, success_order, failure_order);
 
400
    }
 
401
 
 
402
    bool
 
403
    compare_exchange_strong(
 
404
        value_type & expected,
 
405
        value_type const& desired,
 
406
        memory_order success_order,
 
407
        memory_order failure_order) volatile BOOST_NOEXCEPT
 
408
    {
 
409
        storage_type expected_s = 0, desired_s = 0;
 
410
        memcpy(&expected_s, &expected, sizeof(value_type));
 
411
        memcpy(&desired_s, &desired, sizeof(value_type));
 
412
 
 
413
        platform_fence_before(success_order);
 
414
        bool success = platform_cmpxchg64_strong(expected_s, desired_s, &v_);
 
415
 
 
416
        if (success) {
 
417
            platform_fence_after(success_order);
 
418
        } else {
 
419
            platform_fence_after(failure_order);
 
420
            memcpy(&expected, &expected_s, sizeof(value_type));
 
421
        }
 
422
 
 
423
        return success;
 
424
    }
 
425
 
 
426
    bool
 
427
    is_lock_free(void) const volatile BOOST_NOEXCEPT
 
428
    {
 
429
        return true;
 
430
    }
 
431
 
 
432
    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
 
433
private:
 
434
    base_atomic(const base_atomic &) /* = delete */ ;
 
435
    void operator=(const base_atomic &) /* = delete */ ;
 
436
    storage_type v_;
 
437
};
 
438
 
 
439
}
 
440
}
 
441
}
 
442
 
 
443
#endif