assert 64bit atomic args alignment

Author: bratpiorka

src/pool/pool_disjoint.c

@@ -20,6 +20,7 @@
 #include "provider/provider_tracking.h"
 #include "uthash/utlist.h"
 #include "utils_common.h"
+#include "utils_concurrency.h"
 #include "utils_log.h"
 #include "utils_math.h"
 
@@ -895,7 +896,8 @@ umf_memory_pool_ops_t *umfDisjointPoolOps(void) {
 
 umf_disjoint_pool_shared_limits_t *
 umfDisjointPoolSharedLimitsCreate(size_t max_size) {
-    umf_disjoint_pool_shared_limits_t *ptr = umf_ba_global_alloc(sizeof(*ptr));
+    umf_disjoint_pool_shared_limits_t *ptr =
+        umf_ba_global_aligned_alloc(sizeof(*ptr), 64);
     if (ptr == NULL) {
         LOG_ERR("cannot allocate memory for disjoint pool shared limits");
         return NULL;

src/pool/pool_disjoint_internal.h

@@ -101,8 +101,8 @@ typedef struct slab_t {
 } slab_t;
 
 typedef struct umf_disjoint_pool_shared_limits_t {
+    CACHE_ALIGNED size_t total_size; // requires atomic access
     size_t max_size;
-    size_t total_size; // requires atomic access
 } umf_disjoint_pool_shared_limits_t;
 
 typedef struct umf_disjoint_pool_params_t {

src/utils/utils_concurrency.h

@@ -37,6 +37,12 @@
 extern "C" {
 #endif
 
+#ifdef _WIN32
+#define CACHE_ALIGNED __declspec(align(64))
+#else
+#define CACHE_ALIGNED __attribute__((aligned(64)))
+#endif
+
 typedef struct utils_mutex_t {
 #ifdef _WIN32
     CRITICAL_SECTION lock;
@@ -91,28 +97,13 @@ static __inline unsigned char utils_mssb_index(long long value) {
     return (unsigned char)ret;
 }
 
-// There is no good way to do atomic_load on windows...
-#define utils_atomic_load_acquire(object, dest)                                \
-    do {                                                                       \
-        *(LONG64 *)dest =                                                      \
-            InterlockedOr64Acquire((LONG64 volatile *)object, 0);              \
-    } while (0)
-
-#define utils_atomic_store_release(object, desired)                            \
-    InterlockedExchange64((LONG64 volatile *)object, (LONG64)desired)
-
-#define utils_atomic_increment(object)                                         \
-    InterlockedIncrement64((LONG64 volatile *)object)
-
-#define utils_atomic_decrement(object)                                         \
-    InterlockedDecrement64((LONG64 volatile *)object)
-
-#define utils_fetch_and_add64(ptr, value)                                      \
-    InterlockedExchangeAdd64((LONG64 *)(ptr), value)
-
+void utils_atomic_load_acquire(void *ptr, void *dest);
+void utils_atomic_store_release(void *ptr, long long desired);
+void utils_atomic_increment(void *ptr);
+void utils_atomic_decrement(void *ptr);
+void utils_fetch_and_add64(void *ptr, long long value);
 // NOTE: windows version have different order of args
-#define utils_compare_exchange(object, desired, expected)                      \
-    InterlockedCompareExchange64((LONG64 volatile *)object, *expected, *desired)
+void utils_compare_exchange(void *ptr, void *desired, void *expected)
 
 #else // !defined(_WIN32)
 

src/utils/utils_windows_concurrency.c

@@ -7,6 +7,7 @@
  *
  */
 
+#include "utils_common.h"
 #include "utils_concurrency.h"
 
 size_t utils_mutex_get_size(void) { return sizeof(utils_mutex_t); }
@@ -66,6 +67,41 @@ int utils_write_unlock(utils_rwlock_t *rwlock) {
     return 0; // never fails
 }
 
+// There is no good way to do atomic_load on windows...
+void utils_atomic_load_acquire(void *ptr, void *dest) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 64);
+    *(long long *)dest = InterlockedOr64Acquire((long long volatile *)ptr, 0);
+}
+
+void utils_atomic_store_release(void *ptr, long long desired) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 64);
+    InterlockedExchange64((long long volatile *)ptr, desired);
+}
+
+void utils_atomic_increment(void *ptr) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 64);
+    InterlockedIncrement64((long long volatile *)ptr)
+}
+
+void utils_atomic_decrement(void *ptr) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 64);
+    InterlockedDecrement64((long long volatile *)ptr)
+}
+
+void utils_fetch_and_add64(void *ptr, long long value) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 64);
+    InterlockedExchangeAdd64((long long volatile *)(ptr), value);
+}
+
+// NOTE: windows version have different order of args
+void utils_compare_exchange(void *ptr, void *desired, void *expected) {
+    ASSERT_IS_ALIGNED((uintptr_t)ptr, 64);
+    ASSERT_IS_ALIGNED((uintptr_t)desired, 64);
+    ASSERT_IS_ALIGNED((uintptr_t)expected, 64);
+    InterlockedCompareExchange64((long long volatile *)ptr, *expected,
+                                 *desired);
+}
+
 static BOOL CALLBACK initOnceCb(PINIT_ONCE InitOnce, PVOID Parameter,
                                 PVOID *lpContext) {
     (void)InitOnce;  // unused