/usr/include/x86_64-linux-gnu/qcc/posix/atomic.h is in liballjoyn-common-dev-1604 16.04a-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 | /**
* @file
*
* Define atomic read-modify-write memory options
*/
/******************************************************************************
*
*
* Copyright AllSeen Alliance. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
******************************************************************************/
#ifndef _POSIX_QCC_ATOMIC_H
#define _POSIX_QCC_ATOMIC_H
#include <qcc/platform.h>
#ifdef QCC_OS_ANDROID
#include <sys/atomics.h>
#endif
#if defined(QCC_OS_DARWIN)
#include <libkern/OSAtomic.h>
#endif
namespace qcc {
#if defined(QCC_OS_ANDROID)
/**
* Increment an int32_t and return its new value atomically.
*
* @param mem Pointer to int32_t to be incremented.
* @return New value (after increment) of *mem
*/
inline int32_t IncrementAndFetch(volatile int32_t* mem)
{
/*
* Androids built in __atomic_inc operation returns the previous value
* stored in mem. This value has been changed in memory. Since we expect
* the value after the increment to be returned we add one to the value
* returned by __atomic_inc.
*/
return __atomic_inc(mem) + 1;
}
/**
* Decrement an int32_t and return its new value atomically.
*
* @param mem Pointer to int32_t to be decremented.
* @return New value (after decrement) of *mem
*/
inline int32_t DecrementAndFetch(volatile int32_t* mem)
{
/*
* Androids built in __atomic_dec operation returns the previous value
* stored in mem. This value has been changed in memory. Since we expect
* the value after the decrement to be returned we subtract one from the
* value returned by __atomic_dec.
*/
return __atomic_dec(mem) - 1;
}
/**
* Performs an atomic compare-and-exchange operation on the specified values.
* It compares two specified 32-bit values and exchanges with another 32-bit
* value based on the outcome of the comparison.
*
* @param mem Pointer to int32_t to be compared and modified.
* @param expectedValue Expected value of *mem.
* @param newValue New value of *mem after calling this function, if returning true.
* @return true if the initial value of *mem was expectedValue, false otherwise
*/
inline bool CompareAndExchange(volatile int32_t* mem, int32_t expectedValue, int32_t newValue)
{
/* Use strong memory ordering model */
return __atomic_compare_exchange_n(mem, &expectedValue, newValue, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
}
/**
* Performs an atomic compare-and-exchange operation on the specified pointer values.
* It compares two specified pointer values and exchanges with another pointer
* value based on the outcome of the comparison.
*
* @param mem Pointer to the pointer value to be compared and modified.
* @param expectedValue Expected value of *mem.
* @param newValue New value of *mem after calling this function, if returning true.
* @return true if the initial value of *mem was expectedValue, false otherwise
*/
inline bool CompareAndExchangePointer(void* volatile* mem, void* expectedValue, void* newValue)
{
/* Use strong memory ordering model */
return __atomic_compare_exchange_n(mem, &expectedValue, newValue, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
}
#elif defined(QCC_OS_LINUX)
/**
* Increment an int32_t and return its new value atomically.
*
* @param mem Pointer to int32_t to be incremented.
* @return New value (after increment) of *mem
*/
inline int32_t IncrementAndFetch(volatile int32_t* mem) {
return __sync_add_and_fetch(mem, 1);
}
/**
* Decrement an int32_t and return its new value atomically.
*
* @param mem Pointer to int32_t to be decremented.
* @return New value (afer decrement) of *mem
*/
inline int32_t DecrementAndFetch(volatile int32_t* mem) {
return __sync_sub_and_fetch(mem, 1);
}
/**
* Performs an atomic compare-and-exchange operation on the specified values.
* It compares two specified 32-bit values and exchanges with another 32-bit
* value based on the outcome of the comparison.
*
* @param mem Pointer to int32_t to be compared and modified.
* @param expectedValue Expected value of *mem.
* @param newValue New value of *mem after calling this function, if returning true.
* @return true if the initial value of *mem was expectedValue, false otherwise
*/
inline bool CompareAndExchange(volatile int32_t* mem, int32_t expectedValue, int32_t newValue) {
return __sync_bool_compare_and_swap(mem, expectedValue, newValue);
}
/**
* Performs an atomic compare-and-exchange operation on the specified pointer values.
* It compares two specified pointer values and exchanges with another pointer
* value based on the outcome of the comparison.
*
* @param mem Pointer to the pointer value to be compared and modified.
* @param expectedValue Expected value of *mem.
* @param newValue New value of *mem after calling this function, if returning true.
* @return true if the initial value of *mem was expectedValue, false otherwise
*/
inline bool CompareAndExchangePointer(void* volatile* mem, void* expectedValue, void* newValue) {
return __sync_bool_compare_and_swap(mem, expectedValue, newValue);
}
#elif defined(QCC_OS_DARWIN)
/**
* Increment an int32_t and return its new value atomically.
*
* @param mem Pointer to int32_t to be incremented.
* @return New value (after increment) of *mem
*/
inline int32_t IncrementAndFetch(volatile int32_t* mem) {
return OSAtomicIncrement32(mem);
}
/**
* Decrement an int32_t and return its new value atomically.
*
* @param mem Pointer to int32_t to be decremented.
* @return New value (afer decrement) of *mem
*/
inline int32_t DecrementAndFetch(volatile int32_t* mem) {
return OSAtomicDecrement32(mem);
}
/**
* Performs an atomic compare-and-exchange operation on the specified values.
* It compares two specified 32-bit values and exchanges with another 32-bit
* value based on the outcome of the comparison.
*
* @param mem Pointer to int32_t to be compared and modified.
* @param expectedValue Expected value of *mem.
* @param newValue New value of *mem after calling this function, if returning true.
* @return true if the initial value of *mem was expectedValue, false otherwise
*/
inline bool CompareAndExchange(volatile int32_t* mem, int32_t expectedValue, int32_t newValue) {
return OSAtomicCompareAndSwapIntBarrier(expectedValue, newValue, mem);
}
/**
* Performs an atomic compare-and-exchange operation on the specified pointer values.
* It compares two specified pointer values and exchanges with another pointer
* value based on the outcome of the comparison.
*
* @param mem Pointer to the pointer value to be compared and modified.
* @param expectedValue Expected value of *mem.
* @param newValue New value of *mem after calling this function, if returning true.
* @return true if the initial value of *mem was expectedValue, false otherwise
*/
inline bool CompareAndExchangePointer(void* volatile* mem, void* expectedValue, void* newValue) {
return OSAtomicCompareAndSwapPtrBarrier(expectedValue, newValue, mem);
}
#else
/**
* Increment an int32_t and return its new value atomically.
*
* @param mem Pointer to int32_t to be incremented.
* @return New value (afer increment) of *mem
*/
int32_t IncrementAndFetch(volatile int32_t* mem);
/**
* Decrement an int32_t and return its new value atomically.
*
* @param mem Pointer to int32_t to be decremented.
* @return New value (afer decrement) of *mem
*/
int32_t DecrementAndFetch(volatile int32_t* mem);
/**
* Performs an atomic compare-and-exchange operation on the specified values.
* It compares two specified 32-bit values and exchanges with another 32-bit
* value based on the outcome of the comparison.
*
* @param mem Pointer to int32_t to be compared and modified.
* @param expectedValue Expected value of *mem.
* @param newValue New value of *mem after calling this function, if returning true.
* @return true if the initial value of *mem was expectedValue, false otherwise
*/
bool CompareAndExchange(volatile int32_t* mem, int32_t expectedValue, int32_t newValue);
/**
* Performs an atomic compare-and-exchange operation on the specified pointer values.
* It compares two specified pointer values and exchanges with another pointer
* value based on the outcome of the comparison.
*
* @param mem Pointer to the pointer value to be compared and modified.
* @param expectedValue Expected value of *mem.
* @param newValue New value of *mem after calling this function, if returning true.
* @return true if the initial value of *mem was expectedValue, false otherwise
*/
bool CompareAndExchangePointer(void* volatile* mem, void* expectedValue, void* newValue);
#endif
}
#endif
|