stdatomic.h

Go to the documentation of this file.

 
#pragma once
 
#include "klib/compiler.h"
 
typedef volatile unsigned atomic_t;
 
#define LOCK_PREFIX "\n\tlock; "
 
#define barrier() __asm__ __volatile__("" \
                                       :  \
                                       :  \
                                       : "memory")
 
#define cpu_relax() __asm__ __volatile__("pause\n" \
                                         :         \
                                         :         \
                                         : "memory")
 
inline static int atomic_set_and_test(atomic_t *ptr, int value)
{
    // The + in "+r" and "+m" denotes a read-modify-write operand.
    __asm__ __volatile__(LOCK_PREFIX               // Lock
                         "xchgl %0, %1"            // Instruction
                         : "+r"(value), "+m"(*ptr) // Input + Output
                         :                         // No input-only
                         : "memory");              // Side effects
    return value;
}
 
inline static void atomic_set(atomic_t *ptr, int value)
{
    atomic_set_and_test(ptr, value);
}
 
inline static int atomic_read(const atomic_t *ptr)
{
    return READ_ONCE(*ptr);
}
 
inline static int atomic_add(atomic_t *ptr, int value)
{
    // The + in "+r" and "+m" denotes a read-modify-write operand.
    __asm__ __volatile__(LOCK_PREFIX               // Lock
                         "xaddl %0, %1"            // Instruction
                         : "+r"(value), "+m"(*ptr) // Input + Output
                         :                         // No input-only
                         : "memory");              // Side effects
    return value;
}
 
inline static int atomic_sub(atomic_t *ptr, int value)
{
    return atomic_add(ptr, -value);
}
 
inline static int atomic_inc(atomic_t *ptr)
{
    return atomic_add(ptr, 1);
}
 
inline static int atomic_dec(atomic_t *ptr)
{
    return atomic_add(ptr, -1);
}
 
inline static int atomic_add_negative(atomic_t *ptr, int value)
{
    return atomic_add(ptr, value) < 0;
}
 
inline static int atomic_sub_and_test(atomic_t *ptr, int value)
{
    return atomic_sub(ptr, value) == 0;
}
 
inline static int atomic_inc_and_test(atomic_t *ptr)
{
    return atomic_inc(ptr) == 0;
}
 
inline static int atomic_dec_and_test(atomic_t *ptr)
{
    return atomic_dec(ptr) == 0;
}
 
static inline void set_bit(int offset, volatile unsigned long *base)
{
    __asm__ __volatile__("btsl %[offset], %[base]"
                         : [base] "=m"(*(volatile long *)base)
                         : [offset] "Ir"(offset));
}
 
static inline void clear_bit(int offset, volatile unsigned long *base)
{
    __asm__ __volatile__("btrl %[offset],%[base]"
                         : [base] "=m"(*(volatile long *)base)
                         : [offset] "Ir"(offset));
}
 
static inline int test_bit(int offset, volatile unsigned long *base)
{
    int old = 0;
    __asm__ __volatile__("btl %[offset],%[base]\n" // Bit Test
                         "sbbl %[old],%[old]\n"    // Return the previous value.
                         : [old] "=r"(old)
                         : [base] "m"(*(volatile long *)base),
                           [offset] "Ir"(offset));
    return old;
}
 
// == Volatile Variable =======================================================
// In C, and consequently C++, the volatile keyword was intended to:
//     - allow access to memory-mapped I/O devices
//     - allow uses of variables between setjmp and longjmp
//     - allow uses of sig_atomic_t variables in signal handlers.
//
// Operations on volatile variables are not atomic, nor do they establish
// a proper happens-before relationship for threading like with the
// `__asm__` inline blocks.
// This is specified in the relevant standards (C, C++, POSIX, WIN32), and
// volatile variables are not thread-safe in the vast majority of current
// implementations.
// Thus, the usage of volatile keyword as a portable synchronization mechanism
// is discouraged by many C/C++ groups.
 
// == xchg/xchgl ==============================================================