From 90119178c88a534d0a127921c9449d440a2da183 Mon Sep 17 00:00:00 2001 From: Mitya Selivanov <0x7fffff@guattari.ru> Date: Wed, 31 Aug 2022 02:49:04 +0400 Subject: test --- source/kit/atomic.h | 69 ++++++++--------- source/kit/atomic.win32.c | 191 ++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 201 insertions(+), 59 deletions(-) (limited to 'source') diff --git a/source/kit/atomic.h b/source/kit/atomic.h index 5763808..b0235ad 100644 --- a/source/kit/atomic.h +++ b/source/kit/atomic.h @@ -9,8 +9,10 @@ extern "C" { #ifndef _MSC_VER # include -# define KIT_ATOMIC(type_) _Atomic type_ +# define KIT_ATOMIC(type_) type_ _Atomic #else +# define KIT_ATOMIC(type_) type_ volatile + enum { memory_order_relaxed, memory_order_consume, @@ -19,61 +21,60 @@ enum { memory_order_acq_rel, memory_order_seq_cst }; -# define KIT_ATOMIC(type_) volatile type_ -void kit_atomic_store_explicit_8(volatile uint8_t *var, uint8_t value, +void kit_atomic_store_explicit_8(uint8_t volatile *var, uint8_t value, int memory_order); -void kit_atomic_store_explicit_16(volatile uint16_t *var, +void kit_atomic_store_explicit_16(uint16_t volatile *var, uint16_t value, int memory_order); -void kit_atomic_store_explicit_32(volatile uint32_t *var, +void kit_atomic_store_explicit_32(uint32_t volatile *var, uint32_t value, int memory_order); -void kit_atomic_store_explicit_64(volatile uint64_t *var, +void kit_atomic_store_explicit_64(uint64_t volatile *var, uint64_t value, int memory_order); -uint8_t kit_atomic_load_explicit_8(volatile uint8_t *var, +uint8_t kit_atomic_load_explicit_8(uint8_t volatile *var, int memory_order); -uint16_t kit_atomic_load_explicit_16(volatile uint16_t *var, +uint16_t kit_atomic_load_explicit_16(uint16_t volatile *var, int memory_order); -uint32_t kit_atomic_load_explicit_32(volatile uint32_t *var, +uint32_t kit_atomic_load_explicit_32(uint32_t volatile *var, int memory_order); -uint64_t kit_atomic_load_explicit_64(volatile uint64_t *var, +uint64_t kit_atomic_load_explicit_64(uint64_t volatile *var, int memory_order); -uint8_t kit_atomic_exchange_explicit_8(volatile uint8_t *var, +uint8_t kit_atomic_exchange_explicit_8(uint8_t volatile *var, uint8_t value, int memory_order); -uint16_t kit_atomic_exchange_explicit_16(volatile uint16_t *var, +uint16_t kit_atomic_exchange_explicit_16(uint16_t volatile *var, uint16_t value, int memory_order); -uint32_t kit_atomic_exchange_explicit_32(volatile uint32_t *var, +uint32_t kit_atomic_exchange_explicit_32(uint32_t volatile *var, uint32_t value, int memory_order); -uint64_t kit_atomic_exchange_explicit_64(volatile uint64_t *var, +uint64_t kit_atomic_exchange_explicit_64(uint64_t volatile *var, uint64_t value, int memory_order); -uint8_t kit_atomic_fetch_add_explicit_8(volatile uint8_t *var, +uint8_t kit_atomic_fetch_add_explicit_8(uint8_t volatile *var, uint8_t value, int memory_order); -uint16_t kit_atomic_fetch_add_explicit_16(volatile uint16_t *var, +uint16_t kit_atomic_fetch_add_explicit_16(uint16_t volatile *var, uint16_t value, int memory_order); -uint32_t kit_atomic_fetch_add_explicit_32(volatile uint32_t *var, +uint32_t kit_atomic_fetch_add_explicit_32(uint32_t volatile *var, uint32_t value, int memory_order); -uint64_t kit_atomic_fetch_add_explicit_64(volatile uint64_t *var, +uint64_t kit_atomic_fetch_add_explicit_64(uint64_t volatile *var, uint64_t value, int memory_order); @@ -85,19 +86,19 @@ uint64_t kit_atomic_fetch_add_explicit_64(volatile uint64_t *var, static_assert(sizeof(value_) <= sizeof *(var_), \ "Wrong value type"); \ if (sizeof *(var_) == 1) \ - kit_atomic_store_explicit_8((volatile uint8_t *) (var_), \ + kit_atomic_store_explicit_8((uint8_t volatile *) (var_), \ (uint8_t) (value_), \ (memory_order_)); \ if (sizeof *(var_) == 2) \ - kit_atomic_store_explicit_16((volatile uint16_t *) (var_), \ + kit_atomic_store_explicit_16((uint16_t volatile *) (var_), \ (uint16_t) (value_), \ (memory_order_)); \ if (sizeof *(var_) == 4) \ - kit_atomic_store_explicit_32((volatile uint32_t *) (var_), \ + kit_atomic_store_explicit_32((uint32_t volatile *) (var_), \ (uint32_t) (value_), \ (memory_order_)); \ if (sizeof *(var_) == 8) \ - kit_atomic_store_explicit_64((volatile uint64_t *) (var_), \ + kit_atomic_store_explicit_64((uint64_t volatile *) (var_), \ (uint64_t) (value_), \ (memory_order_)); \ } while (0) @@ -107,16 +108,16 @@ uint64_t kit_atomic_fetch_add_explicit_64(volatile uint64_t *var, sizeof *(var_) == 3 || sizeof *(var_) == 4, \ "Wrong atomic variable type"), \ (sizeof *(var_) == 1 \ - ? kit_atomic_load_explicit_8((volatile uint8_t *) (var_), \ + ? kit_atomic_load_explicit_8((uint8_t volatile *) (var_), \ (value_), (memory_order_)) \ : sizeof *(var_) == 2 ? kit_atomic_load_explicit_16( \ - (volatile uint16_t *) (var_), \ + (uint16_t volatile *) (var_), \ (value_), (memory_order_)) \ : sizeof *(var_) == 4 ? kit_atomic_load_explicit_32( \ - (volatile uint32_t *) (var_), \ + (uint32_t volatile *) (var_), \ (value_), (memory_order_)) \ : kit_atomic_load_explicit_64( \ - (volatile uint64_t *) (var_), \ + (uint64_t volatile *) (var_), \ (value_), (memory_order_)))) # define atomic_exchange_explicit(var_, value_, memory_order_) \ @@ -126,18 +127,18 @@ uint64_t kit_atomic_fetch_add_explicit_64(volatile uint64_t *var, static_assert(sizeof(value_) <= sizeof *(var_), \ "Wrong value type"), \ (sizeof *(var_) == 1 ? kit_atomic_exchange_explicit_8( \ - (volatile uint8_t *) (var_), \ + (uint8_t volatile *) (var_), \ (uint8_t) (value_), (memory_order_)) \ : sizeof *(var_) == 2 \ ? kit_atomic_exchange_explicit_16( \ - (volatile uint16_t *) (var_), (uint16_t) (value_), \ + (uint16_t volatile *) (var_), (uint16_t) (value_), \ (memory_order_)) \ : sizeof *(var_) == 4 \ ? kit_atomic_exchange_explicit_32( \ - (volatile uint32_t *) (var_), (uint32_t) (value_), \ + (uint32_t volatile *) (var_), (uint32_t) (value_), \ (memory_order_)) \ : kit_atomic_exchange_explicit_64( \ - (volatile uint64_t *) (var_), (uint64_t) (value_), \ + (uint64_t volatile *) (var_), (uint64_t) (value_), \ (memory_order_)))) # define atomic_fetch_add_explicit(var_, value_, memory_order_) \ @@ -147,18 +148,18 @@ uint64_t kit_atomic_fetch_add_explicit_64(volatile uint64_t *var, static_assert(sizeof(value_) <= sizeof *(var_), \ "Wrong value type"), \ (sizeof *(var_) == 1 ? kit_atomic_fetch_add_explicit_8( \ - (volatile uint8_t *) (var_), \ + (uint8_t volatile *) (var_), \ (uint8_t) (value_), (memory_order_)) \ : sizeof *(var_) == 2 \ ? kit_atomic_fetch_add_explicit_16( \ - (volatile uint16_t *) (var_), (uint16_t) (value_), \ + (uint16_t volatile *) (var_), (uint16_t) (value_), \ (memory_order_)) \ : sizeof *(var_) == 4 \ ? kit_atomic_fetch_add_explicit_32( \ - (volatile uint32_t *) (var_), (uint32_t) (value_), \ + (uint32_t volatile *) (var_), (uint32_t) (value_), \ (memory_order_)) \ : kit_atomic_fetch_add_explicit_64( \ - (volatile uint64_t *) (var_), (uint64_t) (value_), \ + (uint64_t volatile *) (var_), (uint64_t) (value_), \ (memory_order_)))) #endif diff --git a/source/kit/atomic.win32.c b/source/kit/atomic.win32.c index fc5b53d..9977955 100644 --- a/source/kit/atomic.win32.c +++ b/source/kit/atomic.win32.c @@ -1,44 +1,185 @@ #include "atomic.h" #ifdef _MSC_VER +static_assert(sizeof(char) == 1); +static_assert(sizeof(short) == 2); +static_assert(sizeof(long) == 4); + # include -# ifdef _WIN64 -# pragma intrinsic(_InterlockedExchange64) -# pragma intrinsic(_InterlockedExchangeAdd64) +void kit_atomic_store_explicit_8(uint8_t volatile *var, uint8_t value, + int memory_order) { + char volatile *dst = (char volatile *) var; + char src = (char) value; + + switch (memory_order) { + case memory_order_relaxed: *dst = src; break; + default: _InterlockedExchange8(dst, src); + } +} + +void kit_atomic_store_explicit_16(uint16_t volatile *var, + uint16_t value, int memory_order) { + short volatile *dst = (short volatile *) var; + short src = (short) value; + + switch (memory_order) { + case memory_order_relaxed: *dst = src; break; + default: _InterlockedExchange16(dst, src); + } +} + +void kit_atomic_store_explicit_32(uint32_t volatile *var, + uint32_t value, int memory_order) { + long volatile *dst = (long volatile *) var; + long src = (long) value; -# define InterlockedExchange_ _InterlockedExchange64 -# define InterlockedExchangeAdd_ _InterlockedExchangeAdd64 + switch (memory_order) { + case memory_order_relaxed: *dst = src; break; + default: _InterlockedExchange(dst, src); + } +} + +void kit_atomic_store_explicit_64(uint64_t volatile *var, + uint64_t value, int memory_order) { + __int64 volatile *dst = (__int64 volatile *) var; + __int64 src = (__int64) value; + + switch (memory_order) { + case memory_order_relaxed: *dst = src; break; + default: +# ifdef _WIN64 + _InterlockedExchange64(dst, src); # else -# pragma intrinsic(_InterlockedExchange32) -# pragma intrinsic(_InterlockedExchangeAdd32) + _InterlockedExchange((long volatile *) dst, (long) src); +# endif + } +} + +uint8_t kit_atomic_load_explicit_8(volatile uint8_t *var, + int memory_order) { + char volatile *dst = (char volatile *) var; + + if (memory_order == memory_order_relaxed) + return (uint8_t) *dst; + + return (uint8_t) _InterlockedOr8(dst, 0); +} + +uint16_t kit_atomic_load_explicit_16(uint16_t volatile *var, + int memory_order) { + short volatile *dst = (short volatile *) var; + + if (memory_order == memory_order_relaxed) + return (uint16_t) *dst; + + return (uint16_t) _InterlockedOr16(dst, 0); +} + +uint32_t kit_atomic_load_explicit_32(uint32_t volatile *var, + int memory_order) { + long volatile *dst = (long volatile *) var; + + if (memory_order == memory_order_relaxed) + return (uint32_t) *dst; + + return (uint32_t) _InterlockedOr(dst, 0); +} + +uint64_t kit_atomic_load_explicit_64(uint64_t volatile *var, + int memory_order) { + __int64 volatile *dst = (__int64 volatile *) var; -# define InterlockedExchange_ _InterlockedExchange32 -# define InterlockedExchangeAdd_ _InterlockedExchangeAdd32 + if (memory_order == memory_order_relaxed) + return (uint64_t) *dst; + +# ifdef _WIN64 + return (uint64_t) _InterlockedOr64(dst, 0); +# else + return (uint64_t) _InterlockedOr((long volatile *) dst, 0); # endif +} + +uint8_t kit_atomic_exchange_explicit_8(volatile uint8_t *var, + uint8_t value, + int memory_order) { + char volatile *dst = (char volatile *) var; + char src = (char) value; -void kit_atomic_store_explicit(volatile KIT_ATOMIC_VAR *var, - KIT_ATOMIC_VAR value, - int memory_order) { - InterlockedExchange_(var, value); + return (uint8_t) _InterlockedExchange8(dst, src); } -KIT_ATOMIC_VAR kit_atomic_load_explicit(volatile KIT_ATOMIC_VAR *var, +uint16_t kit_atomic_exchange_explicit_16(uint16_t volatile *var, + uint16_t value, + int memory_order) { + short volatile *dst = (short volatile *) var; + short src = (short) value; + + return (uint16_t) _InterlockedExchange16(dst, src); +} + +uint32_t kit_atomic_exchange_explicit_32(uint32_t volatile *var, + uint32_t value, + int memory_order) { + long volatile *dst = (long volatile *) var; + long src = (long) value; + + return (uint32_t) _InterlockedExchange(dst, src); +} + +uint64_t kit_atomic_exchange_explicit_64(uint64_t volatile *var, + uint64_t value, + int memory_order) { + __int64 volatile *dst = (__int64 volatile *) var; + __int64 src = (__int64) value; + +# ifdef _WIN64 + return (uint64_t) _InterlockedExchange64(dst, src); +# else + return (uint64_t) _InterlockedExchange((long volatile *) dst, + (long) src); +# endif +} + +uint8_t kit_atomic_fetch_add_explicit_8(volatile uint8_t *var, + uint8_t value, int memory_order) { - if (memory_order == memory_order_relaxed) - return *var; - return InterlockedExchangeAdd_(var, 0); + char volatile *dst = (char volatile *) var; + char src = (char) value; + + return (uint8_t) _InterlockedExchangeAdd8(dst, src); +} + +uint16_t kit_atomic_fetch_add_explicit_16(uint16_t volatile *var, + uint16_t value, + int memory_order) { + short volatile *dst = (short volatile *) var; + short src = (short) value; + + return (uint16_t) _InterlockedExchangeAdd16(dst, src); } -KIT_ATOMIC_VAR kit_atomic_fetch_add_explicit( - volatile KIT_ATOMIC_VAR *var, KIT_ATOMIC_VAR value, - int memory_order) { - return InterlockedExchangeAdd_(var, value); +uint32_t kit_atomic_fetch_add_explicit_32(uint32_t volatile *var, + uint32_t value, + int memory_order) { + long volatile *dst = (long volatile *) var; + long src = (long) value; + + return (uint32_t) _InterlockedExchangeAdd(dst, src); } -KIT_ATOMIC_VAR kit_atomic_exchange_explicit( - volatile KIT_ATOMIC_VAR *var, KIT_ATOMIC_VAR value, - int memory_order) { - return InterlockedExchange_(var, value); +uint64_t kit_atomic_fetch_add_explicit_64(uint64_t volatile *var, + uint64_t value, + int memory_order) { + __int64 volatile *dst = (__int64 volatile *) var; + __int64 src = (__int64) value; + +# ifdef _WIN64 + return (uint64_t) _InterlockedExchangeAdd64(dst, src); +# else + return (uint64_t) _InterlockedExchangeAdd((long volatile *) dst, + (long) src); +# endif } + #endif -- cgit v1.2.3