atomic.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdatomic.h>
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
// ============================================================================
// Core Atomic Types
// ============================================================================
 
typedef struct {
    _Atomic(uint64_t) impl;  
#ifndef NDEBUG
    uint64_t          last_store_time_ns;
    uint64_t          last_load_time_ns;
    uint64_t          store_count;
    uint64_t          load_count;
    uint64_t          cas_count;
    uint64_t          cas_success_count;
    uint64_t          fetch_count;
#endif
} atomic_t;
 
typedef struct {
    _Atomic(void *)   impl;  
#ifndef NDEBUG
    uint64_t          last_store_time_ns;
    uint64_t          last_load_time_ns;
    uint64_t          store_count;
    uint64_t          load_count;
    uint64_t          cas_count;
    uint64_t          cas_success_count;
    uint64_t          exchange_count;
#endif
} atomic_ptr_t;
 
 
// ============================================================================
// bool Operations
// ============================================================================
 
#ifndef NDEBUG
bool atomic_load_bool(atomic_t *a);
#else
#define atomic_load_bool(a) ((bool)atomic_load_bool_impl(a))
#endif
 
bool atomic_load_bool_impl(const atomic_t *a);
 
#ifndef NDEBUG
void atomic_store_bool(atomic_t *a, bool value);
#else
#define atomic_store_bool(a, value) atomic_store_bool_impl((a), (uint64_t)(value))
#endif
 
void atomic_store_bool_impl(atomic_t *a, uint64_t value);
 
#ifndef NDEBUG
bool atomic_cas_bool(atomic_t *a, bool *expected, bool new_value);
#else
#define atomic_cas_bool(a, expected, new_value) \
    atomic_cas_bool_impl((a), (expected), (new_value))
#endif
 
bool atomic_cas_bool_impl(atomic_t *a, bool *expected, bool new_value);
 
#ifndef NDEBUG
bool atomic_exchange_bool(atomic_t *a, bool new_value);
#else
#define atomic_exchange_bool(a, new_value) \
    atomic_exchange_bool_impl((a), (new_value))
#endif
 
bool atomic_exchange_bool_impl(atomic_t *a, bool new_value);
 
// ============================================================================
// int Operations
// ============================================================================
 
#ifndef NDEBUG
int atomic_load_int(atomic_t *a);
#else
#define atomic_load_int(a) ((int)atomic_load_int_impl(a))
#endif
 
int atomic_load_int_impl(const atomic_t *a);
 
#ifndef NDEBUG
void atomic_store_int(atomic_t *a, int value);
#else
#define atomic_store_int(a, value) atomic_store_int_impl((a), (uint64_t)(int32_t)(value))
#endif
 
void atomic_store_int_impl(atomic_t *a, uint64_t value);
 
#ifndef NDEBUG
int atomic_fetch_add_int(atomic_t *a, int delta);
#else
#define atomic_fetch_add_int(a, delta) \
    ((int)atomic_fetch_add_int_impl((a), (int64_t)(delta)))
#endif
 
int atomic_fetch_add_int_impl(atomic_t *a, int64_t delta);
 
#ifndef NDEBUG
int atomic_fetch_sub_int(atomic_t *a, int delta);
#else
#define atomic_fetch_sub_int(a, delta) \
    ((int)atomic_fetch_sub_int_impl((a), (int64_t)(delta)))
#endif
 
int atomic_fetch_sub_int_impl(atomic_t *a, int64_t delta);
 
#ifndef NDEBUG
bool atomic_cas_int(atomic_t *a, int *expected, int new_value);
#else
#define atomic_cas_int(a, expected, new_value) \
    atomic_cas_int_impl((a), (expected), (new_value))
#endif
 
bool atomic_cas_int_impl(atomic_t *a, int *expected, int new_value);
 
// ============================================================================
// uint64_t Operations
// ============================================================================
 
#ifndef NDEBUG
uint64_t atomic_load_u64(atomic_t *a);
#else
#define atomic_load_u64(a) atomic_load_u64_impl(a)
#endif
 
uint64_t atomic_load_u64_impl(const atomic_t *a);
 
#ifndef NDEBUG
void atomic_store_u64(atomic_t *a, uint64_t value);
#else
#define atomic_store_u64(a, value) atomic_store_u64_impl((a), (value))
#endif
 
void atomic_store_u64_impl(atomic_t *a, uint64_t value);
 
#ifndef NDEBUG
uint64_t atomic_fetch_add_u64(atomic_t *a, uint64_t delta);
#else
#define atomic_fetch_add_u64(a, delta) atomic_fetch_add_u64_impl((a), (delta))
#endif
 
uint64_t atomic_fetch_add_u64_impl(atomic_t *a, uint64_t delta);
 
#ifndef NDEBUG
uint64_t atomic_fetch_sub_u64(atomic_t *a, uint64_t delta);
#else
#define atomic_fetch_sub_u64(a, delta) atomic_fetch_sub_u64_impl((a), (delta))
#endif
 
uint64_t atomic_fetch_sub_u64_impl(atomic_t *a, uint64_t delta);
 
#ifndef NDEBUG
bool atomic_cas_u64(atomic_t *a, uint64_t *expected, uint64_t new_value);
#else
#define atomic_cas_u64(a, expected, new_value) \
    atomic_cas_u64_impl((a), (expected), (new_value))
#endif
 
bool atomic_cas_u64_impl(atomic_t *a, uint64_t *expected, uint64_t new_value);
 
#ifndef NDEBUG
uint64_t atomic_exchange_u64(atomic_t *a, uint64_t new_value);
#else
#define atomic_exchange_u64(a, new_value) \
    atomic_exchange_u64_impl((a), (new_value))
#endif
 
uint64_t atomic_exchange_u64_impl(atomic_t *a, uint64_t new_value);
 
// ============================================================================
// Pointer Operations
// ============================================================================
 
#ifndef NDEBUG
void *atomic_ptr_load(atomic_ptr_t *a);
#else
#define atomic_ptr_load(a) atomic_ptr_load_impl(a)
#endif
 
void *atomic_ptr_load_impl(const atomic_ptr_t *a);
 
#ifndef NDEBUG
void atomic_ptr_store(atomic_ptr_t *a, void *value);
#else
#define atomic_ptr_store(a, value) atomic_ptr_store_impl((a), (value))
#endif
 
void atomic_ptr_store_impl(atomic_ptr_t *a, void *value);
 
#ifndef NDEBUG
bool atomic_ptr_cas(atomic_ptr_t *a, void **expected, void *new_value);
#else
#define atomic_ptr_cas(a, expected, new_value) \
    atomic_ptr_cas_impl((a), (expected), (new_value))
#endif
 
bool atomic_ptr_cas_impl(atomic_ptr_t *a, void **expected, void *new_value);
 
#ifndef NDEBUG
void *atomic_ptr_exchange(atomic_ptr_t *a, void *new_value);
#else
#define atomic_ptr_exchange(a, new_value) \
    atomic_ptr_exchange_impl((a), (new_value))
#endif
 
void *atomic_ptr_exchange_impl(atomic_ptr_t *a, void *new_value);
 
#ifndef NDEBUG
int atomic_exchange_int(atomic_t *a, int new_value);
#else
#define atomic_exchange_int(a, new_value) \
    atomic_exchange_int_impl((a), (new_value))
#endif
 
int atomic_exchange_int_impl(atomic_t *a, int new_value);
 
// ============================================================================
// Debug Hooks (called by _impl functions in debug builds)
// ============================================================================
 
#ifndef NDEBUG
void atomic_on_load(atomic_t *a);
void atomic_on_store(atomic_t *a);
void atomic_on_cas(atomic_t *a, bool success);
void atomic_on_fetch(atomic_t *a);
 
void atomic_ptr_on_load(atomic_ptr_t *a);
void atomic_ptr_on_store(atomic_ptr_t *a);
void atomic_ptr_on_cas(atomic_ptr_t *a, bool success);
void atomic_ptr_on_exchange(atomic_ptr_t *a);
#endif
 
// ============================================================================
// Convenience Macros for Atomic Declaration and Registration
// ============================================================================
 
#define ATOMIC_REGISTER_AUTO(name, parent_ptr) NAMED_REGISTER_ATOMIC(&(name), #name, (uintptr_t)(const void *)(parent_ptr))
 
#define ATOMIC_PTR_REGISTER_AUTO(name) NAMED_REGISTER_ATOMIC_PTR(&(name), #name)
 
// ============================================================================
// Automatic Named Initialization & Registration Macros
// ============================================================================
 
#ifndef NDEBUG
#define ATOMIC_INIT_AUTO(...) = _atomic_init_auto(__VA_ARGS__)
#else
#define ATOMIC_INIT_AUTO(...) = {0}
#endif
 
#ifndef NDEBUG
#define ATOMIC_PTR_INIT_AUTO(...) = _atomic_ptr_init_auto(__VA_ARGS__)
#else
#define ATOMIC_PTR_INIT_AUTO(...) = {0}
#endif
 
// Actual init functions (defined below - use a workaround pattern)
// These are helpers that work with static initialization
#define _atomic_init_auto(name) {0}; \
  static void __attribute__((constructor, used)) _atomic_reg_##name(void) { \
    NAMED_REGISTER_ATOMIC(&name, #name, NULL); \
  } typedef int _atomic_assert_##name
 
#define _atomic_ptr_init_auto(name) {0}; \
  static void __attribute__((constructor, used)) _atomic_ptr_reg_##name(void) { \
    NAMED_REGISTER_ATOMIC_PTR(&name, #name, NULL); \
  } typedef int _atomic_ptr_assert_##name
 
// ============================================================================
// Debug Initialization/Shutdown
// ============================================================================
 
#ifndef NDEBUG
void debug_atomic_init(void);
void debug_atomic_shutdown(void);
bool debug_atomic_is_initialized(void);
void debug_atomic_print_state(void);
#else
#define debug_atomic_init()           ((void)0)
#define debug_atomic_shutdown()       ((void)0)
#define debug_atomic_is_initialized() (true)
#define debug_atomic_print_state()    ((void)0)
#endif
 
#ifdef __cplusplus
}
#endif