atomic.h

/* atomic operations */
 
/*
 * Copyright (c) 1997-2015, Wind River Systems, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef __ATOMIC_H__
#define __ATOMIC_H__
 
#ifdef __cplusplus
extern "C"
{
#endif
 
typedef int atomic_t;
typedef atomic_t atomic_val_t;
 
static inline int atomic_cas(atomic_t *target, atomic_val_t old_value,
        atomic_val_t new_value)
{
    return __atomic_compare_exchange_n(target, &old_value, new_value,
            0, __ATOMIC_SEQ_CST,
            __ATOMIC_SEQ_CST);
}
 
static inline atomic_val_t atomic_add(atomic_t *target, atomic_val_t value)
{
    return __atomic_fetch_add(target, value, __ATOMIC_SEQ_CST);
}
 
static inline atomic_val_t atomic_sub(atomic_t *target, atomic_val_t value)
{
    return __atomic_fetch_sub(target, value, __ATOMIC_SEQ_CST);
}
 
static inline atomic_val_t atomic_inc(atomic_t *target)
{
    return atomic_add(target, 1);
}
 
static inline atomic_val_t atomic_dec(atomic_t *target)
{
    return atomic_sub(target, 1);
}
 
static inline atomic_val_t atomic_get(const atomic_t *target)
{
    return __atomic_load_n(target, __ATOMIC_SEQ_CST);
}
 
static inline atomic_val_t atomic_set(atomic_t *target, atomic_val_t value)
{
    /* This builtin, as described by Intel, is not a traditional
     * test-and-set operation, but rather an atomic exchange operation. It
     * writes value into *ptr, and returns the previous contents of *ptr.
     */
    return __atomic_exchange_n(target, value, __ATOMIC_SEQ_CST);
}
 
static inline atomic_val_t atomic_clear(atomic_t *target)
{
    return atomic_set(target, 0);
}
 
static inline atomic_val_t atomic_or(atomic_t *target, atomic_val_t value)
{
    return __atomic_fetch_or(target, value, __ATOMIC_SEQ_CST);
}
 
static inline atomic_val_t atomic_xor(atomic_t *target, atomic_val_t value)
{
    return __atomic_fetch_xor(target, value, __ATOMIC_SEQ_CST);
}
 
static inline atomic_val_t atomic_and(atomic_t *target, atomic_val_t value)
{
    return __atomic_fetch_and(target, value, __ATOMIC_SEQ_CST);
}
 
static inline atomic_val_t atomic_nand(atomic_t *target, atomic_val_t value)
{
    return __atomic_fetch_nand(target, value, __ATOMIC_SEQ_CST);
}
 
#define ATOMIC_INIT(i) (i)
 
#define ATOMIC_BITS (sizeof(atomic_val_t) * 8)
#define ATOMIC_MASK(bit) (1 << ((bit) & (ATOMIC_BITS - 1)))
#define ATOMIC_ELEM(addr, bit) ((addr) + ((bit) / ATOMIC_BITS))
 
#define ATOMIC_DEFINE(name, num_bits) \
    atomic_t name[1 + ((num_bits) - 1) / ATOMIC_BITS]
 
    static inline int
    atomic_test_bit(const atomic_t *target, int bit)
    {
        atomic_val_t val = atomic_get(ATOMIC_ELEM(target, bit));
 
        return (1 & (val >> (bit & (ATOMIC_BITS - 1))));
    }
 
    static inline int
    atomic_test_and_clear_bit(atomic_t *target, int bit)
    {
        atomic_val_t mask = ATOMIC_MASK(bit);
        atomic_val_t old;
 
        old = atomic_and(ATOMIC_ELEM(target, bit), ~mask);
 
        return (old & mask) != 0;
    }
 
    static inline int
    atomic_test_and_set_bit(atomic_t *target, int bit)
    {
        atomic_val_t mask = ATOMIC_MASK(bit);
        atomic_val_t old;
 
        old = atomic_or(ATOMIC_ELEM(target, bit), mask);
 
        return (old & mask) != 0;
    }
 
    static inline void
    atomic_clear_bit(atomic_t *target, int bit)
    {
        atomic_val_t mask = ATOMIC_MASK(bit);
 
        atomic_and(ATOMIC_ELEM(target, bit), ~mask);
    }
 
    static inline void
    atomic_set_bit(atomic_t *target, int bit)
    {
        atomic_val_t mask = ATOMIC_MASK(bit);
 
        atomic_or(ATOMIC_ELEM(target, bit), mask);
    }
 
static inline void atomic_set_bit_to(atomic_t *target, int bit, bool val)
{
    atomic_val_t mask = ATOMIC_MASK(bit);
 
    if (val) {
        (void)atomic_or(ATOMIC_ELEM(target, bit), mask);
    } else {
        (void)atomic_and(ATOMIC_ELEM(target, bit), ~mask);
    }
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* __ATOMIC_H__ */