From cda59f99701bc3acc569023e197abddc548330f4 Mon Sep 17 00:00:00 2001 From: Jason Evans Date: Mon, 7 Nov 2016 11:27:48 -0800 Subject: [PATCH] Rename atomic_*_{uint32,uint64,u}() to atomic_*_{u32,u64,zu}(). This change conforms to naming conventions throughout the codebase. --- include/jemalloc/internal/arena.h | 6 +- include/jemalloc/internal/atomic.h | 198 +++++++++--------- include/jemalloc/internal/private_symbols.txt | 24 +-- include/jemalloc/internal/prng.h | 8 +- include/jemalloc/internal/stats.h | 2 +- src/arena.c | 4 +- src/extent.c | 12 +- test/unit/atomic.c | 24 +-- 8 files changed, 139 insertions(+), 139 deletions(-) diff --git a/include/jemalloc/internal/arena.h b/include/jemalloc/internal/arena.h index dbd334e6..f518c31f 100644 --- a/include/jemalloc/internal/arena.h +++ b/include/jemalloc/internal/arena.h @@ -365,21 +365,21 @@ JEMALLOC_INLINE void arena_metadata_add(arena_t *arena, size_t size) { - atomic_add_z(&arena->stats.metadata, size); + atomic_add_zu(&arena->stats.metadata, size); } JEMALLOC_INLINE void arena_metadata_sub(arena_t *arena, size_t size) { - atomic_sub_z(&arena->stats.metadata, size); + atomic_sub_zu(&arena->stats.metadata, size); } JEMALLOC_INLINE size_t arena_metadata_get(arena_t *arena) { - return (atomic_read_z(&arena->stats.metadata)); + return (atomic_read_zu(&arena->stats.metadata)); } JEMALLOC_INLINE bool diff --git a/include/jemalloc/internal/atomic.h b/include/jemalloc/internal/atomic.h index 3f15ea14..4b5b4ea9 100644 --- a/include/jemalloc/internal/atomic.h +++ b/include/jemalloc/internal/atomic.h @@ -9,10 +9,12 @@ /******************************************************************************/ #ifdef JEMALLOC_H_EXTERNS -#define atomic_read_uint64(p) atomic_add_uint64(p, 0) -#define atomic_read_uint32(p) atomic_add_uint32(p, 0) +#if (LG_SIZEOF_PTR == 3 || LG_SIZEOF_INT == 3) +#define atomic_read_u64(p) atomic_add_u64(p, 0) +#endif +#define atomic_read_u32(p) atomic_add_u32(p, 0) #define atomic_read_p(p) atomic_add_p(p, NULL) -#define atomic_read_z(p) atomic_add_z(p, 0) +#define atomic_read_zu(p) atomic_add_zu(p, 0) #define atomic_read_u(p) atomic_add_u(p, 0) #endif /* JEMALLOC_H_EXTERNS */ @@ -41,22 +43,24 @@ */ #ifndef JEMALLOC_ENABLE_INLINE -uint64_t atomic_add_uint64(uint64_t *p, uint64_t x); -uint64_t atomic_sub_uint64(uint64_t *p, uint64_t x); -bool atomic_cas_uint64(uint64_t *p, uint64_t c, uint64_t s); -void atomic_write_uint64(uint64_t *p, uint64_t x); -uint32_t atomic_add_uint32(uint32_t *p, uint32_t x); -uint32_t atomic_sub_uint32(uint32_t *p, uint32_t x); -bool atomic_cas_uint32(uint32_t *p, uint32_t c, uint32_t s); -void atomic_write_uint32(uint32_t *p, uint32_t x); +# if (LG_SIZEOF_PTR == 3 || LG_SIZEOF_INT == 3) +uint64_t atomic_add_u64(uint64_t *p, uint64_t x); +uint64_t atomic_sub_u64(uint64_t *p, uint64_t x); +bool atomic_cas_u64(uint64_t *p, uint64_t c, uint64_t s); +void atomic_write_u64(uint64_t *p, uint64_t x); +# endif +uint32_t atomic_add_u32(uint32_t *p, uint32_t x); +uint32_t atomic_sub_u32(uint32_t *p, uint32_t x); +bool atomic_cas_u32(uint32_t *p, uint32_t c, uint32_t s); +void atomic_write_u32(uint32_t *p, uint32_t x); void *atomic_add_p(void **p, void *x); void *atomic_sub_p(void **p, void *x); bool atomic_cas_p(void **p, void *c, void *s); void atomic_write_p(void **p, const void *x); -size_t atomic_add_z(size_t *p, size_t x); -size_t atomic_sub_z(size_t *p, size_t x); -bool atomic_cas_z(size_t *p, size_t c, size_t s); -void atomic_write_z(size_t *p, size_t x); +size_t atomic_add_zu(size_t *p, size_t x); +size_t atomic_sub_zu(size_t *p, size_t x); +bool atomic_cas_zu(size_t *p, size_t c, size_t s); +void atomic_write_zu(size_t *p, size_t x); unsigned atomic_add_u(unsigned *p, unsigned x); unsigned atomic_sub_u(unsigned *p, unsigned x); bool atomic_cas_u(unsigned *p, unsigned c, unsigned s); @@ -69,7 +73,7 @@ void atomic_write_u(unsigned *p, unsigned x); #if (LG_SIZEOF_PTR == 3 || LG_SIZEOF_INT == 3) # if (defined(__amd64__) || defined(__x86_64__)) JEMALLOC_INLINE uint64_t -atomic_add_uint64(uint64_t *p, uint64_t x) +atomic_add_u64(uint64_t *p, uint64_t x) { uint64_t t = x; @@ -83,7 +87,7 @@ atomic_add_uint64(uint64_t *p, uint64_t x) } JEMALLOC_INLINE uint64_t -atomic_sub_uint64(uint64_t *p, uint64_t x) +atomic_sub_u64(uint64_t *p, uint64_t x) { uint64_t t; @@ -99,7 +103,7 @@ atomic_sub_uint64(uint64_t *p, uint64_t x) } JEMALLOC_INLINE bool -atomic_cas_uint64(uint64_t *p, uint64_t c, uint64_t s) +atomic_cas_u64(uint64_t *p, uint64_t c, uint64_t s) { uint8_t success; @@ -115,7 +119,7 @@ atomic_cas_uint64(uint64_t *p, uint64_t c, uint64_t s) } JEMALLOC_INLINE void -atomic_write_uint64(uint64_t *p, uint64_t x) +atomic_write_u64(uint64_t *p, uint64_t x) { asm volatile ( @@ -127,35 +131,35 @@ atomic_write_uint64(uint64_t *p, uint64_t x) } # elif (defined(JEMALLOC_C11ATOMICS)) JEMALLOC_INLINE uint64_t -atomic_add_uint64(uint64_t *p, uint64_t x) +atomic_add_u64(uint64_t *p, uint64_t x) { volatile atomic_uint_least64_t *a = (volatile atomic_uint_least64_t *)p; return (atomic_fetch_add(a, x) + x); } JEMALLOC_INLINE uint64_t -atomic_sub_uint64(uint64_t *p, uint64_t x) +atomic_sub_u64(uint64_t *p, uint64_t x) { volatile atomic_uint_least64_t *a = (volatile atomic_uint_least64_t *)p; return (atomic_fetch_sub(a, x) - x); } JEMALLOC_INLINE bool -atomic_cas_uint64(uint64_t *p, uint64_t c, uint64_t s) +atomic_cas_u64(uint64_t *p, uint64_t c, uint64_t s) { volatile atomic_uint_least64_t *a = (volatile atomic_uint_least64_t *)p; return (!atomic_compare_exchange_strong(a, &c, s)); } JEMALLOC_INLINE void -atomic_write_uint64(uint64_t *p, uint64_t x) +atomic_write_u64(uint64_t *p, uint64_t x) { volatile atomic_uint_least64_t *a = (volatile atomic_uint_least64_t *)p; atomic_store(a, x); } # elif (defined(JEMALLOC_ATOMIC9)) JEMALLOC_INLINE uint64_t -atomic_add_uint64(uint64_t *p, uint64_t x) +atomic_add_u64(uint64_t *p, uint64_t x) { /* @@ -168,7 +172,7 @@ atomic_add_uint64(uint64_t *p, uint64_t x) } JEMALLOC_INLINE uint64_t -atomic_sub_uint64(uint64_t *p, uint64_t x) +atomic_sub_u64(uint64_t *p, uint64_t x) { assert(sizeof(uint64_t) == sizeof(unsigned long)); @@ -177,7 +181,7 @@ atomic_sub_uint64(uint64_t *p, uint64_t x) } JEMALLOC_INLINE bool -atomic_cas_uint64(uint64_t *p, uint64_t c, uint64_t s) +atomic_cas_u64(uint64_t *p, uint64_t c, uint64_t s) { assert(sizeof(uint64_t) == sizeof(unsigned long)); @@ -186,7 +190,7 @@ atomic_cas_uint64(uint64_t *p, uint64_t c, uint64_t s) } JEMALLOC_INLINE void -atomic_write_uint64(uint64_t *p, uint64_t x) +atomic_write_u64(uint64_t *p, uint64_t x) { assert(sizeof(uint64_t) == sizeof(unsigned long)); @@ -195,53 +199,53 @@ atomic_write_uint64(uint64_t *p, uint64_t x) } # elif (defined(JEMALLOC_OSATOMIC)) JEMALLOC_INLINE uint64_t -atomic_add_uint64(uint64_t *p, uint64_t x) +atomic_add_u64(uint64_t *p, uint64_t x) { return (OSAtomicAdd64((int64_t)x, (int64_t *)p)); } JEMALLOC_INLINE uint64_t -atomic_sub_uint64(uint64_t *p, uint64_t x) +atomic_sub_u64(uint64_t *p, uint64_t x) { return (OSAtomicAdd64(-((int64_t)x), (int64_t *)p)); } JEMALLOC_INLINE bool -atomic_cas_uint64(uint64_t *p, uint64_t c, uint64_t s) +atomic_cas_u64(uint64_t *p, uint64_t c, uint64_t s) { return (!OSAtomicCompareAndSwap64(c, s, (int64_t *)p)); } JEMALLOC_INLINE void -atomic_write_uint64(uint64_t *p, uint64_t x) +atomic_write_u64(uint64_t *p, uint64_t x) { uint64_t o; /*The documented OSAtomic*() API does not expose an atomic exchange. */ do { - o = atomic_read_uint64(p); - } while (atomic_cas_uint64(p, o, x)); + o = atomic_read_u64(p); + } while (atomic_cas_u64(p, o, x)); } # elif (defined(_MSC_VER)) JEMALLOC_INLINE uint64_t -atomic_add_uint64(uint64_t *p, uint64_t x) +atomic_add_u64(uint64_t *p, uint64_t x) { return (InterlockedExchangeAdd64(p, x) + x); } JEMALLOC_INLINE uint64_t -atomic_sub_uint64(uint64_t *p, uint64_t x) +atomic_sub_u64(uint64_t *p, uint64_t x) { return (InterlockedExchangeAdd64(p, -((int64_t)x)) - x); } JEMALLOC_INLINE bool -atomic_cas_uint64(uint64_t *p, uint64_t c, uint64_t s) +atomic_cas_u64(uint64_t *p, uint64_t c, uint64_t s) { uint64_t o; @@ -250,7 +254,7 @@ atomic_cas_uint64(uint64_t *p, uint64_t c, uint64_t s) } JEMALLOC_INLINE void -atomic_write_uint64(uint64_t *p, uint64_t x) +atomic_write_u64(uint64_t *p, uint64_t x) { InterlockedExchange64(p, x); @@ -258,28 +262,28 @@ atomic_write_uint64(uint64_t *p, uint64_t x) # elif (defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) || \ defined(JE_FORCE_SYNC_COMPARE_AND_SWAP_8)) JEMALLOC_INLINE uint64_t -atomic_add_uint64(uint64_t *p, uint64_t x) +atomic_add_u64(uint64_t *p, uint64_t x) { return (__sync_add_and_fetch(p, x)); } JEMALLOC_INLINE uint64_t -atomic_sub_uint64(uint64_t *p, uint64_t x) +atomic_sub_u64(uint64_t *p, uint64_t x) { return (__sync_sub_and_fetch(p, x)); } JEMALLOC_INLINE bool -atomic_cas_uint64(uint64_t *p, uint64_t c, uint64_t s) +atomic_cas_u64(uint64_t *p, uint64_t c, uint64_t s) { return (!__sync_bool_compare_and_swap(p, c, s)); } JEMALLOC_INLINE void -atomic_write_uint64(uint64_t *p, uint64_t x) +atomic_write_u64(uint64_t *p, uint64_t x) { __sync_lock_test_and_set(p, x); @@ -293,7 +297,7 @@ atomic_write_uint64(uint64_t *p, uint64_t x) /* 32-bit operations. */ #if (defined(__i386__) || defined(__amd64__) || defined(__x86_64__)) JEMALLOC_INLINE uint32_t -atomic_add_uint32(uint32_t *p, uint32_t x) +atomic_add_u32(uint32_t *p, uint32_t x) { uint32_t t = x; @@ -307,7 +311,7 @@ atomic_add_uint32(uint32_t *p, uint32_t x) } JEMALLOC_INLINE uint32_t -atomic_sub_uint32(uint32_t *p, uint32_t x) +atomic_sub_u32(uint32_t *p, uint32_t x) { uint32_t t; @@ -323,7 +327,7 @@ atomic_sub_uint32(uint32_t *p, uint32_t x) } JEMALLOC_INLINE bool -atomic_cas_uint32(uint32_t *p, uint32_t c, uint32_t s) +atomic_cas_u32(uint32_t *p, uint32_t c, uint32_t s) { uint8_t success; @@ -339,7 +343,7 @@ atomic_cas_uint32(uint32_t *p, uint32_t c, uint32_t s) } JEMALLOC_INLINE void -atomic_write_uint32(uint32_t *p, uint32_t x) +atomic_write_u32(uint32_t *p, uint32_t x) { asm volatile ( @@ -351,109 +355,109 @@ atomic_write_uint32(uint32_t *p, uint32_t x) } # elif (defined(JEMALLOC_C11ATOMICS)) JEMALLOC_INLINE uint32_t -atomic_add_uint32(uint32_t *p, uint32_t x) +atomic_add_u32(uint32_t *p, uint32_t x) { volatile atomic_uint_least32_t *a = (volatile atomic_uint_least32_t *)p; return (atomic_fetch_add(a, x) + x); } JEMALLOC_INLINE uint32_t -atomic_sub_uint32(uint32_t *p, uint32_t x) +atomic_sub_u32(uint32_t *p, uint32_t x) { volatile atomic_uint_least32_t *a = (volatile atomic_uint_least32_t *)p; return (atomic_fetch_sub(a, x) - x); } JEMALLOC_INLINE bool -atomic_cas_uint32(uint32_t *p, uint32_t c, uint32_t s) +atomic_cas_u32(uint32_t *p, uint32_t c, uint32_t s) { volatile atomic_uint_least32_t *a = (volatile atomic_uint_least32_t *)p; return (!atomic_compare_exchange_strong(a, &c, s)); } JEMALLOC_INLINE void -atomic_write_uint32(uint32_t *p, uint32_t x) +atomic_write_u32(uint32_t *p, uint32_t x) { volatile atomic_uint_least32_t *a = (volatile atomic_uint_least32_t *)p; atomic_store(a, x); } #elif (defined(JEMALLOC_ATOMIC9)) JEMALLOC_INLINE uint32_t -atomic_add_uint32(uint32_t *p, uint32_t x) +atomic_add_u32(uint32_t *p, uint32_t x) { return (atomic_fetchadd_32(p, x) + x); } JEMALLOC_INLINE uint32_t -atomic_sub_uint32(uint32_t *p, uint32_t x) +atomic_sub_u32(uint32_t *p, uint32_t x) { return (atomic_fetchadd_32(p, (uint32_t)(-(int32_t)x)) - x); } JEMALLOC_INLINE bool -atomic_cas_uint32(uint32_t *p, uint32_t c, uint32_t s) +atomic_cas_u32(uint32_t *p, uint32_t c, uint32_t s) { return (!atomic_cmpset_32(p, c, s)); } JEMALLOC_INLINE void -atomic_write_uint32(uint32_t *p, uint32_t x) +atomic_write_u32(uint32_t *p, uint32_t x) { atomic_store_rel_32(p, x); } #elif (defined(JEMALLOC_OSATOMIC)) JEMALLOC_INLINE uint32_t -atomic_add_uint32(uint32_t *p, uint32_t x) +atomic_add_u32(uint32_t *p, uint32_t x) { return (OSAtomicAdd32((int32_t)x, (int32_t *)p)); } JEMALLOC_INLINE uint32_t -atomic_sub_uint32(uint32_t *p, uint32_t x) +atomic_sub_u32(uint32_t *p, uint32_t x) { return (OSAtomicAdd32(-((int32_t)x), (int32_t *)p)); } JEMALLOC_INLINE bool -atomic_cas_uint32(uint32_t *p, uint32_t c, uint32_t s) +atomic_cas_u32(uint32_t *p, uint32_t c, uint32_t s) { return (!OSAtomicCompareAndSwap32(c, s, (int32_t *)p)); } JEMALLOC_INLINE void -atomic_write_uint32(uint32_t *p, uint32_t x) +atomic_write_u32(uint32_t *p, uint32_t x) { uint32_t o; /*The documented OSAtomic*() API does not expose an atomic exchange. */ do { - o = atomic_read_uint32(p); - } while (atomic_cas_uint32(p, o, x)); + o = atomic_read_u32(p); + } while (atomic_cas_u32(p, o, x)); } #elif (defined(_MSC_VER)) JEMALLOC_INLINE uint32_t -atomic_add_uint32(uint32_t *p, uint32_t x) +atomic_add_u32(uint32_t *p, uint32_t x) { return (InterlockedExchangeAdd(p, x) + x); } JEMALLOC_INLINE uint32_t -atomic_sub_uint32(uint32_t *p, uint32_t x) +atomic_sub_u32(uint32_t *p, uint32_t x) { return (InterlockedExchangeAdd(p, -((int32_t)x)) - x); } JEMALLOC_INLINE bool -atomic_cas_uint32(uint32_t *p, uint32_t c, uint32_t s) +atomic_cas_u32(uint32_t *p, uint32_t c, uint32_t s) { uint32_t o; @@ -462,7 +466,7 @@ atomic_cas_uint32(uint32_t *p, uint32_t c, uint32_t s) } JEMALLOC_INLINE void -atomic_write_uint32(uint32_t *p, uint32_t x) +atomic_write_u32(uint32_t *p, uint32_t x) { InterlockedExchange(p, x); @@ -470,28 +474,28 @@ atomic_write_uint32(uint32_t *p, uint32_t x) #elif (defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) || \ defined(JE_FORCE_SYNC_COMPARE_AND_SWAP_4)) JEMALLOC_INLINE uint32_t -atomic_add_uint32(uint32_t *p, uint32_t x) +atomic_add_u32(uint32_t *p, uint32_t x) { return (__sync_add_and_fetch(p, x)); } JEMALLOC_INLINE uint32_t -atomic_sub_uint32(uint32_t *p, uint32_t x) +atomic_sub_u32(uint32_t *p, uint32_t x) { return (__sync_sub_and_fetch(p, x)); } JEMALLOC_INLINE bool -atomic_cas_uint32(uint32_t *p, uint32_t c, uint32_t s) +atomic_cas_u32(uint32_t *p, uint32_t c, uint32_t s) { return (!__sync_bool_compare_and_swap(p, c, s)); } JEMALLOC_INLINE void -atomic_write_uint32(uint32_t *p, uint32_t x) +atomic_write_u32(uint32_t *p, uint32_t x) { __sync_lock_test_and_set(p, x); @@ -507,9 +511,9 @@ atomic_add_p(void **p, void *x) { #if (LG_SIZEOF_PTR == 3) - return ((void *)atomic_add_uint64((uint64_t *)p, (uint64_t)x)); + return ((void *)atomic_add_u64((uint64_t *)p, (uint64_t)x)); #elif (LG_SIZEOF_PTR == 2) - return ((void *)atomic_add_uint32((uint32_t *)p, (uint32_t)x)); + return ((void *)atomic_add_u32((uint32_t *)p, (uint32_t)x)); #endif } @@ -518,11 +522,9 @@ atomic_sub_p(void **p, void *x) { #if (LG_SIZEOF_PTR == 3) - return ((void *)atomic_add_uint64((uint64_t *)p, - (uint64_t)-((int64_t)x))); + return ((void *)atomic_add_u64((uint64_t *)p, (uint64_t)-((int64_t)x))); #elif (LG_SIZEOF_PTR == 2) - return ((void *)atomic_add_uint32((uint32_t *)p, - (uint32_t)-((int32_t)x))); + return ((void *)atomic_add_u32((uint32_t *)p, (uint32_t)-((int32_t)x))); #endif } @@ -531,9 +533,9 @@ atomic_cas_p(void **p, void *c, void *s) { #if (LG_SIZEOF_PTR == 3) - return (atomic_cas_uint64((uint64_t *)p, (uint64_t)c, (uint64_t)s)); + return (atomic_cas_u64((uint64_t *)p, (uint64_t)c, (uint64_t)s)); #elif (LG_SIZEOF_PTR == 2) - return (atomic_cas_uint32((uint32_t *)p, (uint32_t)c, (uint32_t)s)); + return (atomic_cas_u32((uint32_t *)p, (uint32_t)c, (uint32_t)s)); #endif } @@ -542,57 +544,55 @@ atomic_write_p(void **p, const void *x) { #if (LG_SIZEOF_PTR == 3) - atomic_write_uint64((uint64_t *)p, (uint64_t)x); + atomic_write_u64((uint64_t *)p, (uint64_t)x); #elif (LG_SIZEOF_PTR == 2) - atomic_write_uint32((uint32_t *)p, (uint32_t)x); + atomic_write_u32((uint32_t *)p, (uint32_t)x); #endif } /******************************************************************************/ /* size_t operations. */ JEMALLOC_INLINE size_t -atomic_add_z(size_t *p, size_t x) +atomic_add_zu(size_t *p, size_t x) { #if (LG_SIZEOF_PTR == 3) - return ((size_t)atomic_add_uint64((uint64_t *)p, (uint64_t)x)); + return ((size_t)atomic_add_u64((uint64_t *)p, (uint64_t)x)); #elif (LG_SIZEOF_PTR == 2) - return ((size_t)atomic_add_uint32((uint32_t *)p, (uint32_t)x)); + return ((size_t)atomic_add_u32((uint32_t *)p, (uint32_t)x)); #endif } JEMALLOC_INLINE size_t -atomic_sub_z(size_t *p, size_t x) +atomic_sub_zu(size_t *p, size_t x) { #if (LG_SIZEOF_PTR == 3) - return ((size_t)atomic_add_uint64((uint64_t *)p, - (uint64_t)-((int64_t)x))); + return ((size_t)atomic_add_u64((uint64_t *)p, (uint64_t)-((int64_t)x))); #elif (LG_SIZEOF_PTR == 2) - return ((size_t)atomic_add_uint32((uint32_t *)p, - (uint32_t)-((int32_t)x))); + return ((size_t)atomic_add_u32((uint32_t *)p, (uint32_t)-((int32_t)x))); #endif } JEMALLOC_INLINE bool -atomic_cas_z(size_t *p, size_t c, size_t s) +atomic_cas_zu(size_t *p, size_t c, size_t s) { #if (LG_SIZEOF_PTR == 3) - return (atomic_cas_uint64((uint64_t *)p, (uint64_t)c, (uint64_t)s)); + return (atomic_cas_u64((uint64_t *)p, (uint64_t)c, (uint64_t)s)); #elif (LG_SIZEOF_PTR == 2) - return (atomic_cas_uint32((uint32_t *)p, (uint32_t)c, (uint32_t)s)); + return (atomic_cas_u32((uint32_t *)p, (uint32_t)c, (uint32_t)s)); #endif } JEMALLOC_INLINE void -atomic_write_z(size_t *p, size_t x) +atomic_write_zu(size_t *p, size_t x) { #if (LG_SIZEOF_PTR == 3) - atomic_write_uint64((uint64_t *)p, (uint64_t)x); + atomic_write_u64((uint64_t *)p, (uint64_t)x); #elif (LG_SIZEOF_PTR == 2) - atomic_write_uint32((uint32_t *)p, (uint32_t)x); + atomic_write_u32((uint32_t *)p, (uint32_t)x); #endif } @@ -603,9 +603,9 @@ atomic_add_u(unsigned *p, unsigned x) { #if (LG_SIZEOF_INT == 3) - return ((unsigned)atomic_add_uint64((uint64_t *)p, (uint64_t)x)); + return ((unsigned)atomic_add_u64((uint64_t *)p, (uint64_t)x)); #elif (LG_SIZEOF_INT == 2) - return ((unsigned)atomic_add_uint32((uint32_t *)p, (uint32_t)x)); + return ((unsigned)atomic_add_u32((uint32_t *)p, (uint32_t)x)); #endif } @@ -614,10 +614,10 @@ atomic_sub_u(unsigned *p, unsigned x) { #if (LG_SIZEOF_INT == 3) - return ((unsigned)atomic_add_uint64((uint64_t *)p, + return ((unsigned)atomic_add_u64((uint64_t *)p, (uint64_t)-((int64_t)x))); #elif (LG_SIZEOF_INT == 2) - return ((unsigned)atomic_add_uint32((uint32_t *)p, + return ((unsigned)atomic_add_u32((uint32_t *)p, (uint32_t)-((int32_t)x))); #endif } @@ -627,9 +627,9 @@ atomic_cas_u(unsigned *p, unsigned c, unsigned s) { #if (LG_SIZEOF_INT == 3) - return (atomic_cas_uint64((uint64_t *)p, (uint64_t)c, (uint64_t)s)); + return (atomic_cas_u64((uint64_t *)p, (uint64_t)c, (uint64_t)s)); #elif (LG_SIZEOF_INT == 2) - return (atomic_cas_uint32((uint32_t *)p, (uint32_t)c, (uint32_t)s)); + return (atomic_cas_u32((uint32_t *)p, (uint32_t)c, (uint32_t)s)); #endif } @@ -638,9 +638,9 @@ atomic_write_u(unsigned *p, unsigned x) { #if (LG_SIZEOF_INT == 3) - atomic_write_uint64((uint64_t *)p, (uint64_t)x); + atomic_write_u64((uint64_t *)p, (uint64_t)x); #elif (LG_SIZEOF_INT == 2) - atomic_write_uint32((uint32_t *)p, (uint32_t)x); + atomic_write_u32((uint32_t *)p, (uint32_t)x); #endif } diff --git a/include/jemalloc/internal/private_symbols.txt b/include/jemalloc/internal/private_symbols.txt index f178daf7..707ede3a 100644 --- a/include/jemalloc/internal/private_symbols.txt +++ b/include/jemalloc/internal/private_symbols.txt @@ -73,24 +73,24 @@ arenas arenas_tdata_cleanup atomic_add_p atomic_add_u -atomic_add_uint32 -atomic_add_uint64 -atomic_add_z +atomic_add_u32 +atomic_add_u64 +atomic_add_zu atomic_cas_p atomic_cas_u -atomic_cas_uint32 -atomic_cas_uint64 -atomic_cas_z +atomic_cas_u32 +atomic_cas_u64 +atomic_cas_zu atomic_sub_p atomic_sub_u -atomic_sub_uint32 -atomic_sub_uint64 -atomic_sub_z +atomic_sub_u32 +atomic_sub_u64 +atomic_sub_zu atomic_write_p atomic_write_u -atomic_write_uint32 -atomic_write_uint64 -atomic_write_z +atomic_write_u32 +atomic_write_u64 +atomic_write_zu base_alloc base_boot base_postfork_child diff --git a/include/jemalloc/internal/prng.h b/include/jemalloc/internal/prng.h index c2bda19c..94fd55a7 100644 --- a/include/jemalloc/internal/prng.h +++ b/include/jemalloc/internal/prng.h @@ -93,9 +93,9 @@ prng_lg_range_u32(uint32_t *state, unsigned lg_range, bool atomic) uint32_t state0; do { - state0 = atomic_read_uint32(state); + state0 = atomic_read_u32(state); state1 = prng_state_next_u32(state0); - } while (atomic_cas_uint32(state, state0, state1)); + } while (atomic_cas_u32(state, state0, state1)); } else { state1 = prng_state_next_u32(*state); *state = state1; @@ -133,9 +133,9 @@ prng_lg_range_zu(size_t *state, unsigned lg_range, bool atomic) size_t state0; do { - state0 = atomic_read_z(state); + state0 = atomic_read_zu(state); state1 = prng_state_next_zu(state0); - } while (atomic_cas_z(state, state0, state1)); + } while (atomic_cas_zu(state, state0, state1)); } else { state1 = prng_state_next_zu(*state); *state = state1; diff --git a/include/jemalloc/internal/stats.h b/include/jemalloc/internal/stats.h index 52279f56..a7368a72 100644 --- a/include/jemalloc/internal/stats.h +++ b/include/jemalloc/internal/stats.h @@ -101,7 +101,7 @@ struct arena_stats_s { uint64_t purged; /* Number of bytes currently allocated for internal metadata. */ - size_t metadata; /* Protected via atomic_*_z(). */ + size_t metadata; /* Protected via atomic_*_zu(). */ size_t allocated_large; uint64_t nmalloc_large; diff --git a/src/arena.c b/src/arena.c index 4b104a0e..ff7b0cd0 100644 --- a/src/arena.c +++ b/src/arena.c @@ -1541,7 +1541,7 @@ ssize_t arena_decay_time_default_get(void) { - return ((ssize_t)atomic_read_z((size_t *)&decay_time_default)); + return ((ssize_t)atomic_read_zu((size_t *)&decay_time_default)); } bool @@ -1550,7 +1550,7 @@ arena_decay_time_default_set(ssize_t decay_time) if (!arena_decay_time_valid(decay_time)) return (true); - atomic_write_z((size_t *)&decay_time_default, (size_t)decay_time); + atomic_write_zu((size_t *)&decay_time_default, (size_t)decay_time); return (false); } diff --git a/src/extent.c b/src/extent.c index 4027e8b7..34ac63e8 100644 --- a/src/extent.c +++ b/src/extent.c @@ -291,14 +291,14 @@ extent_register(tsdn_t *tsdn, const extent_t *extent) if (config_prof && opt_prof && extent_active_get(extent)) { size_t nadd = extent_size_get(extent) >> LG_PAGE; - size_t cur = atomic_add_z(&curpages, nadd); - size_t high = atomic_read_z(&highpages); - while (cur > high && atomic_cas_z(&highpages, high, cur)) { + size_t cur = atomic_add_zu(&curpages, nadd); + size_t high = atomic_read_zu(&highpages); + while (cur > high && atomic_cas_zu(&highpages, high, cur)) { /* * Don't refresh cur, because it may have decreased * since this thread lost the highpages update race. */ - high = atomic_read_z(&highpages); + high = atomic_read_zu(&highpages); } if (cur > high && prof_gdump_get_unlocked()) prof_gdump(tsdn); @@ -347,8 +347,8 @@ extent_deregister(tsdn_t *tsdn, extent_t *extent) if (config_prof && opt_prof && extent_active_get(extent)) { size_t nsub = extent_size_get(extent) >> LG_PAGE; - assert(atomic_read_z(&curpages) >= nsub); - atomic_sub_z(&curpages, nsub); + assert(atomic_read_zu(&curpages) >= nsub); + atomic_sub_zu(&curpages, nsub); } } diff --git a/test/unit/atomic.c b/test/unit/atomic.c index bdd74f65..b8933a69 100644 --- a/test/unit/atomic.c +++ b/test/unit/atomic.c @@ -65,23 +65,23 @@ typedef struct p##_test_s p##_test_t; } \ } while (0) -TEST_STRUCT(uint64, uint64_t) -TEST_BEGIN(test_atomic_uint64) +TEST_STRUCT(u64, uint64_t) +TEST_BEGIN(test_atomic_u64) { #if !(LG_SIZEOF_PTR == 3 || LG_SIZEOF_INT == 3) test_skip("64-bit atomic operations not supported"); #else - TEST_BODY(uint64, uint64_t, uint64_t, u64, FMTx64); + TEST_BODY(u64, uint64_t, uint64_t, u64, FMTx64); #endif } TEST_END -TEST_STRUCT(uint32, uint32_t) -TEST_BEGIN(test_atomic_uint32) +TEST_STRUCT(u32, uint32_t) +TEST_BEGIN(test_atomic_u32) { - TEST_BODY(uint32, uint32_t, uint32_t, u32, "#"FMTx32); + TEST_BODY(u32, uint32_t, uint32_t, u32, "#"FMTx32); } TEST_END @@ -93,11 +93,11 @@ TEST_BEGIN(test_atomic_p) } TEST_END -TEST_STRUCT(z, size_t) -TEST_BEGIN(test_atomic_z) +TEST_STRUCT(zu, size_t) +TEST_BEGIN(test_atomic_zu) { - TEST_BODY(z, size_t, size_t, zu, "#zx"); + TEST_BODY(zu, size_t, size_t, zu, "#zx"); } TEST_END @@ -114,9 +114,9 @@ main(void) { return (test( - test_atomic_uint64, - test_atomic_uint32, + test_atomic_u64, + test_atomic_u32, test_atomic_p, - test_atomic_z, + test_atomic_zu, test_atomic_u)); }