Refactor thread-local storage to use _Thread_local instead of __thread for better compliance with the C11 standard.

nkallima · nkallima · commit 3c5075ab627e · 2024-12-12T10:50:51.000+02:00
diff --git a/benchmarks/clhqueuebench.c b/benchmarks/clhqueuebench.c
@@ -31,7 +31,7 @@ int64_t d1 CACHE_ALIGN, d2;
 SynchBarrier bar CACHE_ALIGN;
 SynchBenchArgs bench_args CACHE_ALIGN;
 
-__thread SynchPoolStruct pool_node;
+_Thread_local SynchPoolStruct pool_node;
 
 static void enqueue(Object arg, int pid) {
     Node *n = synchAllocObj(&pool_node);
diff --git a/benchmarks/clhstackbench.c b/benchmarks/clhstackbench.c
@@ -26,7 +26,7 @@ int64_t d1 CACHE_ALIGN, d2;
 SynchBarrier bar CACHE_ALIGN;
 SynchBenchArgs bench_args CACHE_ALIGN;
 
-__thread SynchPoolStruct pool_node;
+_Thread_local SynchPoolStruct pool_node;
 
 static void push(Object arg, int pid) {
     volatile Node *n = synchAllocObj(&pool_node);
diff --git a/libconcurrent/concurrent/ccqueue.c b/libconcurrent/concurrent/ccqueue.c
@@ -4,7 +4,7 @@
 static RetVal serialEnqueue(void *state, ArgVal arg, int pid);
 static RetVal serialDequeue(void *state, ArgVal arg, int pid);
 
-static __thread SynchPoolStruct pool_node CACHE_ALIGN;
+static _Thread_local SynchPoolStruct pool_node CACHE_ALIGN;
 
 void CCQueueStructInit(CCQueueStruct *queue_object_struct, uint32_t nthreads) {
     CCSynchStructInit(&queue_object_struct->enqueue_struct, nthreads);
diff --git a/libconcurrent/concurrent/ccstack.c b/libconcurrent/concurrent/ccstack.c
@@ -4,7 +4,7 @@
 static RetVal serialPushPop(void *state, ArgVal arg, int pid);
 
 static const int POP_OP = INT_MIN;
-static __thread SynchPoolStruct pool_node CACHE_ALIGN;
+static _Thread_local SynchPoolStruct pool_node CACHE_ALIGN;
 
 void CCStackInit(CCStackStruct *stack_object_struct, uint32_t nthreads) {
     CCSynchStructInit(&stack_object_struct->object_struct, nthreads);
diff --git a/libconcurrent/concurrent/dsmqueue.c b/libconcurrent/concurrent/dsmqueue.c
@@ -4,7 +4,7 @@
 static RetVal serialEnqueue(void *state, ArgVal arg, int pid);
 static RetVal serialDequeue(void *state, ArgVal arg, int pid);
 
-static __thread SynchPoolStruct pool_node CACHE_ALIGN;
+static _Thread_local SynchPoolStruct pool_node CACHE_ALIGN;
 
 void DSMQueueStructInit(DSMQueueStruct *queue_object_struct, uint32_t nthreads) {
     DSMSynchStructInit(&queue_object_struct->enqueue_struct, nthreads);
diff --git a/libconcurrent/concurrent/dsmstack.c b/libconcurrent/concurrent/dsmstack.c
@@ -4,7 +4,7 @@
 static RetVal serialPushPop(void *state, ArgVal arg, int pid);
 
 static const int POP_OP = INT_MIN;
-static __thread SynchPoolStruct pool_node CACHE_ALIGN;
+static _Thread_local SynchPoolStruct pool_node CACHE_ALIGN;
 
 void DSMSStackInit(DSMStackStruct *stack_object_struct, uint32_t nthreads) {
     DSMSynchStructInit(&stack_object_struct->object_struct, nthreads);
diff --git a/libconcurrent/concurrent/fcqueue.c b/libconcurrent/concurrent/fcqueue.c
@@ -8,7 +8,7 @@ static RetVal serialEnqueue(void *state, ArgVal arg, int pid);
 static RetVal serialDequeue(void *state, ArgVal arg, int pid);
 
 static const int GUARD = INT_MIN;
-static __thread SynchPoolStruct pool_node CACHE_ALIGN;
+static _Thread_local SynchPoolStruct pool_node CACHE_ALIGN;
 
 void FCQueueStructInit(FCQueueStruct *queue_object_struct, uint32_t nthreads) {
     FCStructInit(&queue_object_struct->enqueue_struct, nthreads);
diff --git a/libconcurrent/concurrent/fcstack.c b/libconcurrent/concurrent/fcstack.c
@@ -5,7 +5,7 @@
 #include <queue-stack.h>
 
 static const int POP_OP = INT_MIN;
-static __thread SynchPoolStruct pool_node CACHE_ALIGN;
+static _Thread_local SynchPoolStruct pool_node CACHE_ALIGN;
 
 void FCStackInit(FCStackStruct *stack_object_struct, uint32_t nthreads) {
     FCStructInit(&stack_object_struct->object_struct, nthreads);
diff --git a/libconcurrent/concurrent/hqueue.c b/libconcurrent/concurrent/hqueue.c
@@ -4,7 +4,7 @@
 static RetVal serialEnqueue(void *state, ArgVal arg, int pid);
 static RetVal serialDequeue(void *state, ArgVal arg, int pid);
 
-static __thread SynchPoolStruct pool_node CACHE_ALIGN;
+static _Thread_local SynchPoolStruct pool_node CACHE_ALIGN;
 
 void HQueueInit(HQueueStruct *queue_object_struct, uint32_t nthreads, uint32_t numa_nodes) {
     queue_object_struct->enqueue_struct = synchGetAlignedMemory(S_CACHE_LINE_SIZE, sizeof(HSynchStruct));
diff --git a/libconcurrent/concurrent/hstack.c b/libconcurrent/concurrent/hstack.c
@@ -4,7 +4,7 @@
 static RetVal serialPushPop(void *state, ArgVal arg, int pid);
 
 static const int POP_OP = INT_MIN;
-static __thread SynchPoolStruct pool_node CACHE_ALIGN;
+static _Thread_local SynchPoolStruct pool_node CACHE_ALIGN;
 
 void HStackInit(HStackStruct *stack_object_struct, uint32_t nthreads, uint32_t numa_nodes) {
     HSynchStructInit(&stack_object_struct->object_struct, nthreads, numa_nodes);
diff --git a/libconcurrent/concurrent/hsynch.c b/libconcurrent/concurrent/hsynch.c
@@ -10,7 +10,7 @@
 #define HSYNCH_HELP_FACTOR            10
 #define HSYNCH_DEFAULT_NUMA_NODE_SIZE 8
 
-static __thread int node_of_thread = 0;
+static _Thread_local int node_of_thread = 0;
 
 RetVal HSynchApplyOp(HSynchStruct *l, HSynchThreadState *st_thread, RetVal (*sfunc)(void *, ArgVal, int), void *state, ArgVal arg, int pid) {
     volatile HSynchNode *p;
diff --git a/libconcurrent/includes/primitives.h b/libconcurrent/includes/primitives.h
@@ -27,7 +27,15 @@
 /// @brief This is return whenever the system is not initialized.
 #define UNINITIALIZED_MACHINE_MODEL 0xFFFFFFFF
 
-#if defined(__GNUC__) && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40100
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_ATOMICS__)
+#    if !defined(__STDC_NO_THREADS__)
+#        // Thread storage is supported
+#    elif !defined(__STDC_NO_THREADS__) && defined(__GNUC__)
+#        define _Thread_local           __thread
+#    else 
+#        error Current compiler does not support standard thread-local storage
+#    endif
+
 #    define __CAS128(A, B0, B1, C0, C1) _CAS128(A, B0, B1, C0, C1)
 #    define __CASPTR(A, B, C)           __sync_bool_compare_and_swap((long *)A, (long)B, (long)C)
 #    define __CAS64(A, B, C)            __sync_bool_compare_and_swap(A, B, C)
@@ -43,6 +51,7 @@
 #    define synchLikely(A)              __builtin_expect(!!(A), 1)
 #    define synchUnlikely(A)            __builtin_expect(!!(A), 0)
 #    define UNUSED_ARG                  __attribute__((unused))
+
 #    if defined(__amd64__) || defined(__x86_64__)
 #        define synchLoadFence()  __asm__ volatile("lfence" ::: "memory")
 #        define synchStoreFence() __asm__ volatile("sfence" ::: "memory")
@@ -54,27 +63,11 @@
 #        define synchFullFence()   __sync_synchronize()
 #        define synchNonTSOFence() __sync_synchronize()
 #    endif
-#elif defined(__GNUC__) && (defined(__amd64__) || defined(__x86_64__))
-#    warning You may lose performance!
-#    warning A newer version of GCC compiler is recommended!
-#    define synchLoadFence()      __asm__ volatile("lfence" ::: "memory")
-#    define synchStoreFence()     __asm__ volatile("sfence" ::: "memory")
-#    define synchFullFence()      __asm__ volatile("mfence" ::: "memory")
-#    define synchReadPrefetch(A)  __asm__ volatile("prefetchnta %0" ::"m"(*((const int *)A)))
-#    define synchStorePrefetch(A) __asm__ volatile("prefetchnta %0" ::"m"(*((const int *)A)))
-#    define synchNonTSOFence()
-#    define synchLikely(A)   (A)
-#    define synchUnlikely(A) (A)
-#    define UNUSED_ARG       __attribute__((unused))
-//   in this case where gcc is too old, implement atomic primitives in primitives.c
-#    define __OLD_GCC_X86__
-int synchBitSearchFirst(uint64_t B);
-uint64_t synchNonZeroBits(uint64_t v);
 #else
 #    error Current machine architecture and compiler are not supported yet!
 #endif
 
-#if defined(__GNUC__) && (defined(__amd64__) || defined(__x86_64__))
+#if defined(__amd64__) || defined(__x86_64__)
 /// @brief This macro is designed to emit a pause instruction specifically for Intel X86 processors.
 /// The inclusion of a pause instruction in spinning loops can significantly improve performance
 /// on Intel X86 machines by reducing the execution resource requirements and improving the performance
@@ -89,10 +82,10 @@ uint64_t synchNonZeroBits(uint64_t v);
             if (synchGetMachineModel() != INTEL_X86_MACHINE)                                                                                                                                           \
                 return;                                                                                                                                                                                \
             for (__i = 0; __i < 16; __i++) {                                                                                                                                                           \
-                __asm__ volatile("pause");                                                                                                                                                                 \
-                __asm__ volatile("pause");                                                                                                                                                                 \
-                __asm__ volatile("pause");                                                                                                                                                                 \
-                __asm__ volatile("pause");                                                                                                                                                                 \
+                __asm__ volatile("pause");                                                                                                                                                             \
+                __asm__ volatile("pause");                                                                                                                                                             \
+                __asm__ volatile("pause");                                                                                                                                                             \
+                __asm__ volatile("pause");                                                                                                                                                             \
             }                                                                                                                                                                                          \
         }
 #else
diff --git a/libconcurrent/primitives/fastrand.c b/libconcurrent/primitives/fastrand.c
@@ -2,9 +2,9 @@
 #include <limits.h>
 #include <math.h>
 
-static __thread long __fast_random_next = 1;
-static __thread uint32_t __fast_random_next_z = 2;
-static __thread uint32_t __fast_random_next_w = 2;
+static _Thread_local long __fast_random_next = 1;
+static _Thread_local uint32_t __fast_random_next_z = 2;
+static _Thread_local uint32_t __fast_random_next_w = 2;
 
 long synchFastRandom(void) {
     __fast_random_next = __fast_random_next * 1103515245 + 12345;
diff --git a/libconcurrent/primitives/primitives.c b/libconcurrent/primitives/primitives.c
@@ -11,109 +11,13 @@
 
 #define MAX_VENDOR_STR_SIZE 64
 
-static __thread uint32_t __machine_model = UNINITIALIZED_MACHINE_MODEL;
+static _Thread_local uint32_t __machine_model = UNINITIALIZED_MACHINE_MODEL;
 
 #ifdef DEBUG
-extern __thread int64_t __failed_cas;
-extern __thread int64_t __executed_cas;
-extern __thread int64_t __executed_swap;
-extern __thread int64_t __executed_faa;
-#endif
-
-#ifdef __OLD_GCC_X86__
-bool __CASPTR(void *A, void *B, void *C) {
-    uint64_t prev;
-    uint64_t *p = (uint64_t *)A;
-
-    __asm__ volatile("lock;"
-                 "cmpxchgq %1,%2" 
-                 : "=a"(prev)
-                 : "r"((uint64_t)C), "m"(*p), "0"((uint64_t)B) 
-                 : "memory");
-    return (prev == (uint64_t)B);
-}
-
-bool __CAS64(volatile uint64_t *A, uint64_t B, uint64_t C) {
-    uint64_t prev;
-    uint64_t *p = (uint64_t *)A;
-
-    __asm__ volatile("lock;"
-                 "cmpxchgq %1,%2"
-                 : "=a"(prev)
-                 : "r"(C), "m"(*p), "0"(B)
-                 : "memory");
-    return (prev == B);
-}
-
-bool __CAS32(uint32_t *A, uint32_t B, uint32_t C) {
-    uint32_t prev;
-    uint32_t *p = (uint32_t *)A;
-
-    __asm__ volatile("lock;"
-                 "cmpxchgl %1,%2" 
-                 : "=a"(prev) 
-                 : "r"(C), "m"(*p), "0"(B) 
-                 : "memory");
-    return (prev == B);
-}
-
-void *__SWAP(void *A, void *B) {
-    int64_t *p = (int64_t *)A;
-
-    __asm__ volatile("lock;"
-                 "xchgq %0, %1"
-                 : "=r"(B), "=m"(*p)
-                 : "0"(B), "m"(*p)
-                 : "memory");
-    return B;
-}
-
-int64_t __FAA64(volatile int64_t *A, int64_t B) {
-    __asm__ volatile("lock;"
-                 "xaddq %0, %1"
-                 : "=r"(B), "=m"(*A)
-                 : "0"(B), "m"(*A)
-                 : "memory");
-    return B;
-}
-
-int32_t __FAA32(volatile int32_t *A, int32_t B) {
-    __asm__ volatile("lock;"
-                 "xaddl %0, %1"
-                 : "=r"(B), "=m"(*A)
-                 : "0"(B), "m"(*A)
-                 : "memory");
-    return B;
-}
-
-uint64_t __BitTAS64(volatile uint64_t *A, unsigned char B) {
-    int64_t *p = (int64_t *)A;
-    int64_t bit = B;
-    __asm__ volatile("lock;" 
-                 "btsq %0, %1"
-                 : "=r"(bit), "=m"(*p)
-                 : "0"(bit), "m"(*p)
-                 : "memory");
-
-    return bit;
-}
-
-int synchBitSearchFirst(uint64_t B) {
-    uint64_t A;
-
-    __asm__("bsfq %0, %1;" : "=d"(A) : "d"(B));
-
-    return (int)A;
-}
-
-uint64_t synchNonZeroBits(uint64_t v) {
-    uint64_t c;
-
-    for (c = 0; v; v >>= 1)
-        c += v & 1;
-
-    return c;
-}
+extern _Thread_local int64_t __failed_cas;
+extern _Thread_local int64_t __executed_cas;
+extern _Thread_local int64_t __executed_swap;
+extern _Thread_local int64_t __executed_faa;
 #endif
 
 bool _CAS128(uint64_t *A, uint64_t B0, uint64_t B1, uint64_t C0, uint64_t C1) {
diff --git a/libconcurrent/primitives/stats.c b/libconcurrent/primitives/stats.c
@@ -7,10 +7,10 @@
 #    include <types.h>
 #    include <system.h>
 
-__thread int64_t __failed_cas CACHE_ALIGN = 0;
-__thread int64_t __executed_cas CACHE_ALIGN = 0;
-__thread int64_t __executed_swap CACHE_ALIGN = 0;
-__thread int64_t __executed_faa CACHE_ALIGN = 0;
+_Thread_local int64_t __failed_cas CACHE_ALIGN = 0;
+_Thread_local int64_t __executed_cas CACHE_ALIGN = 0;
+_Thread_local int64_t __executed_swap CACHE_ALIGN = 0;
+_Thread_local int64_t __executed_faa CACHE_ALIGN = 0;
 
 volatile int64_t __total_failed_cas = 0;
 volatile int64_t __total_executed_cas = 0;
diff --git a/libconcurrent/primitives/threadtools.c b/libconcurrent/primitives/threadtools.c
@@ -17,11 +17,11 @@
 static void *uthreadWrapper(void *arg);
 static void *kthreadWrapper(void *arg);
 
-static __thread pthread_t *__threads;
-static __thread int32_t __thread_id = 0;
-static __thread int32_t __preferred_numa_node = 0;
-static __thread int32_t __preferred_core = 0;
-static __thread int32_t __unjoined_threads = 0;
+static _Thread_local pthread_t *_Thread_locals;
+static _Thread_local int32_t _Thread_local_id = 0;
+static _Thread_local int32_t __preferred_numa_node = 0;
+static _Thread_local int32_t __preferred_core = 0;
+static _Thread_local int32_t __unjoined_threads = 0;
 
 static void *(*__func)(void *) CACHE_ALIGN = NULL;
 static uint32_t __uthreads = 0;
@@ -46,7 +46,7 @@ uint32_t synchGetThreadPlacementPolicy(void) {
 }
 
 void setThreadId(int32_t id) {
-    __thread_id = id;
+    _Thread_local_id = id;
 }
 
 int32_t synchGetPreferredCore(void) {
@@ -204,7 +204,7 @@ int synchStartThreadsN(uint32_t nthreads, void *(*func)(void *), uint32_t uthrea
     synchInitCPUCounters();
     __ncores = sysconf(_SC_NPROCESSORS_ONLN);
     __nthreads = nthreads;
-    __threads = synchGetMemory(nthreads * sizeof(pthread_t));
+    _Thread_locals = synchGetMemory(nthreads * sizeof(pthread_t));
     __func = func;
     synchStoreFence();
     if (uthreads != SYNCH_DONT_USE_UTHREADS && uthreads > 1) {
@@ -213,7 +213,7 @@ int synchStartThreadsN(uint32_t nthreads, void *(*func)(void *), uint32_t uthrea
         __system_oversubscription = true;
         synchBarrierSet(&bar, nthreads / uthreads + 1);
         for (i = 0; i < (nthreads / uthreads) - 1; i++) {
-            last_thread_id = pthread_create(&__threads[i], NULL, uthreadWrapper, (void *)(i * uthreads));
+            last_thread_id = pthread_create(&_Thread_locals[i], NULL, uthreadWrapper, (void *)(i * uthreads));
             if (last_thread_id != 0) {
                 perror("pthread_create");
                 exit(EXIT_FAILURE);
@@ -229,7 +229,7 @@ int synchStartThreadsN(uint32_t nthreads, void *(*func)(void *), uint32_t uthrea
             __noop_resched = true;
         synchBarrierSet(&bar, nthreads + 1);
         for (i = 0; i < nthreads - 1; i++) {
-            last_thread_id = pthread_create(&__threads[i], NULL, kthreadWrapper, (void *)i);
+            last_thread_id = pthread_create(&_Thread_locals[i], NULL, kthreadWrapper, (void *)i);
             if (last_thread_id != 0) {
                 perror("pthread_create");
                 exit(EXIT_FAILURE);
@@ -243,15 +243,15 @@ int synchStartThreadsN(uint32_t nthreads, void *(*func)(void *), uint32_t uthrea
 
 void synchJoinThreadsN(uint32_t nthreads) {
     synchBarrierLastLeave(&bar);
-    synchFreeMemory(__threads, nthreads * sizeof(pthread_t));
+    synchFreeMemory(_Thread_locals, nthreads * sizeof(pthread_t));
 }
 
 int32_t synchGetThreadId(void) {
-    return __thread_id + synchCurrentFiberIndex();
+    return _Thread_local_id + synchCurrentFiberIndex();
 }
 
 int32_t synchGetPosixThreadId(void) {
-    return __thread_id;
+    return _Thread_local_id;
 }
 
 void synchResched(void) {
diff --git a/libconcurrent/primitives/uthreads.c b/libconcurrent/primitives/uthreads.c
@@ -18,11 +18,11 @@ typedef struct FiberData {
 static void switch_to_fiber(Fiber *prev, Fiber *cur);
 static void fiber_start_func(FiberData *context);
 
-static volatile __thread int N_FIBERS = 1;
-static __thread Fiber *FIBER_LIST = NULL;
-static __thread Fiber *FIBER_RECYCLE = NULL;
-static __thread int MAX_FIBERS = 1;
-static __thread int currentFiber = 0;
+static volatile _Thread_local int N_FIBERS = 1;
+static _Thread_local Fiber *FIBER_LIST = NULL;
+static _Thread_local Fiber *FIBER_RECYCLE = NULL;
+static _Thread_local int MAX_FIBERS = 1;
+static _Thread_local int currentFiber = 0;
 
 void synchInitFibers(int max) {
     int i;
