← Back to branch summary

~ubuntu-branches/ubuntu/wily/davix/wily

« back to all changes in this revision

Viewing changes to deps/boost_intern/boost/atomic/detail/cas64strong.hpp

  • Committer: Package Import Robot
  • Author(s): Mattias Ellert
  • Date: 2015-07-31 13:17:55 UTC
  • mfrom: (5.1.3 sid)
  • Revision ID: package-import@ubuntu.com-20150731131755-mizprbmn7ogv33te
Tags: 0.4.1-1
* Update to version 0.4.1
* Implement Multi-Arch support

Show diffs side-by-side

added added

removed removed

Lines of Context:
deps/boost_intern/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 on integers/UDTs from platform_cmpxchg64_strong
12
 
// primitive. It is assumed that 64-bit loads/stores are not
13
 
// atomic, so they are implemented through platform_load64/platform_store64.
14
 
 
15
 
#include <string.h>
16
 
#include <cstddef>
17
 
#include <boost/cstdint.hpp>
18
 
#include <boost/memory_order.hpp>
19
 
#include <boost/atomic/detail/config.hpp>
20
 
#include <boost/atomic/detail/base.hpp>
21
 
 
22
 
#ifdef BOOST_HAS_PRAGMA_ONCE
23
 
#pragma once
24
 
#endif
25
 
 
26
 
namespace boost {
27
 
namespace atomics {
28
 
namespace detail {
29
 
 
30
 
/* integral types */
31
 
 
32
 
template<typename T, bool Sign>
33
 
class base_atomic<T, int, 8, Sign>
34
 
{
35
 
private:
36
 
    typedef base_atomic this_type;
37
 
    typedef T value_type;
38
 
    typedef T difference_type;
39
 
 
40
 
protected:
41
 
    typedef value_type value_arg_type;
42
 
 
43
 
public:
44
 
    BOOST_DEFAULTED_FUNCTION(base_atomic(void), {})
45
 
    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
46
 
 
47
 
    void
48
 
    store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
49
 
    {
50
 
        platform_fence_before_store(order);
51
 
        platform_store64(v, &v_);
52
 
        platform_fence_after_store(order);
53
 
    }
54
 
 
55
 
    value_type
56
 
    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
57
 
    {
58
 
        value_type v = platform_load64(&v_);
59
 
        platform_fence_after_load(order);
60
 
        return v;
61
 
    }
62
 
 
63
 
    value_type
64
 
    exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
65
 
    {
66
 
        value_type original = load(memory_order_relaxed);
67
 
        do {
68
 
        } while (!compare_exchange_weak(original, v, order, memory_order_relaxed));
69
 
        return original;
70
 
    }
71
 
 
72
 
    bool
73
 
    compare_exchange_weak(
74
 
        value_type & expected,
75
 
        value_type desired,
76
 
        memory_order success_order,
77
 
        memory_order failure_order) volatile BOOST_NOEXCEPT
78
 
    {
79
 
        return compare_exchange_strong(expected, desired, success_order, failure_order);
80
 
    }
81
 
 
82
 
    bool
83
 
    compare_exchange_strong(
84
 
        value_type & expected,
85
 
        value_type desired,
86
 
        memory_order success_order,
87
 
        memory_order failure_order) volatile BOOST_NOEXCEPT
88
 
    {
89
 
        platform_fence_before(success_order);
90
 
 
91
 
        bool success = platform_cmpxchg64_strong(expected, desired, &v_);
92
 
 
93
 
        if (success) {
94
 
            platform_fence_after(success_order);
95
 
        } else {
96
 
            platform_fence_after(failure_order);
97
 
        }
98
 
 
99
 
        return success;
100
 
    }
101
 
 
102
 
    value_type
103
 
    fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
104
 
    {
105
 
        value_type original = load(memory_order_relaxed);
106
 
        do {
107
 
        } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed));
108
 
        return original;
109
 
    }
110
 
 
111
 
    value_type
112
 
    fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
113
 
    {
114
 
        value_type original = load(memory_order_relaxed);
115
 
        do {
116
 
        } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed));
117
 
        return original;
118
 
    }
119
 
 
120
 
    value_type
121
 
    fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
122
 
    {
123
 
        value_type original = load(memory_order_relaxed);
124
 
        do {
125
 
        } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed));
126
 
        return original;
127
 
    }
128
 
 
129
 
    value_type
130
 
    fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
131
 
    {
132
 
        value_type original = load(memory_order_relaxed);
133
 
        do {
134
 
        } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed));
135
 
        return original;
136
 
    }
137
 
 
138
 
    value_type
139
 
    fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
140
 
    {
141
 
        value_type original = load(memory_order_relaxed);
142
 
        do {
143
 
        } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed));
144
 
        return original;
145
 
    }
146
 
 
147
 
    bool
148
 
    is_lock_free(void) const volatile BOOST_NOEXCEPT
149
 
    {
150
 
        return true;
151
 
    }
152
 
 
153
 
    BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS
154
 
 
155
 
    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
156
 
    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
157
 
 
158
 
private:
159
 
    value_type v_;
160
 
};
161
 
 
162
 
/* generic types */
163
 
 
164
 
template<typename T, bool Sign>
165
 
class base_atomic<T, void, 8, Sign>
166
 
{
167
 
private:
168
 
    typedef base_atomic this_type;
169
 
    typedef T value_type;
170
 
    typedef uint64_t storage_type;
171
 
 
172
 
protected:
173
 
    typedef value_type const& value_arg_type;
174
 
 
175
 
public:
176
 
    BOOST_DEFAULTED_FUNCTION(base_atomic(void), {})
177
 
    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
178
 
    {
179
 
        memcpy(&v_, &v, sizeof(value_type));
180
 
    }
181
 
 
182
 
    void
183
 
    store(value_type const& value, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
184
 
    {
185
 
        storage_type value_s = 0;
186
 
        memcpy(&value_s, &value, sizeof(value_type));
187
 
        platform_fence_before_store(order);
188
 
        platform_store64(value_s, &v_);
189
 
        platform_fence_after_store(order);
190
 
    }
191
 
 
192
 
    value_type
193
 
    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
194
 
    {
195
 
        storage_type value_s = platform_load64(&v_);
196
 
        platform_fence_after_load(order);
197
 
        value_type value;
198
 
        memcpy(&value, &value_s, sizeof(value_type));
199
 
        return value;
200
 
    }
201
 
 
202
 
    value_type
203
 
    exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
204
 
    {
205
 
        value_type original = load(memory_order_relaxed);
206
 
        do {
207
 
        } while (!compare_exchange_weak(original, v, order, memory_order_relaxed));
208
 
        return original;
209
 
    }
210
 
 
211
 
    bool
212
 
    compare_exchange_weak(
213
 
        value_type & expected,
214
 
        value_type const& desired,
215
 
        memory_order success_order,
216
 
        memory_order failure_order) volatile BOOST_NOEXCEPT
217
 
    {
218
 
        return compare_exchange_strong(expected, desired, success_order, failure_order);
219
 
    }
220
 
 
221
 
    bool
222
 
    compare_exchange_strong(
223
 
        value_type & expected,
224
 
        value_type const& desired,
225
 
        memory_order success_order,
226
 
        memory_order failure_order) volatile BOOST_NOEXCEPT
227
 
    {
228
 
        storage_type expected_s = 0, desired_s = 0;
229
 
        memcpy(&expected_s, &expected, sizeof(value_type));
230
 
        memcpy(&desired_s, &desired, sizeof(value_type));
231
 
 
232
 
        platform_fence_before(success_order);
233
 
        bool success = platform_cmpxchg64_strong(expected_s, desired_s, &v_);
234
 
 
235
 
        if (success) {
236
 
            platform_fence_after(success_order);
237
 
        } else {
238
 
            platform_fence_after(failure_order);
239
 
            memcpy(&expected, &expected_s, sizeof(value_type));
240
 
        }
241
 
 
242
 
        return success;
243
 
    }
244
 
 
245
 
    bool
246
 
    is_lock_free(void) const volatile BOOST_NOEXCEPT
247
 
    {
248
 
        return true;
249
 
    }
250
 
 
251
 
    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
252
 
 
253
 
    BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
254
 
    BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
255
 
 
256
 
private:
257
 
    storage_type v_;
258
 
};
259
 
 
260
 
}
261
 
}
262
 
}
263
 
 
264
 
#endif