Fix atomics cross-platform

Author: cfnptr

include/mpmt/atomic.h

@@ -23,6 +23,7 @@
  */
 
 // TODO: compare exchange, test/set/clear, thread fences and barriers.
+// TODO: relaxed barrier functions.
 
 #pragma once
 
@@ -135,102 +136,102 @@
 
 /***********************************************************************************************************************
  * @brief Atomically performs AND operation to the variable that memory points to.
- * @return The resulting value of the AND operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the AND operation is to be performed
  * @param value variable whose value is to be used for an AND operation
  */
-#define atomicAndFetch8(memory, value) __atomic_and_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchAnd8(memory, value) __atomic_fetch_and(memory, value, __ATOMIC_SEQ_CST)
 /**
  * @brief Atomically performs AND operation to the variable that memory points to.
- * @return The resulting value of the AND operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the AND operation is to be performed
  * @param value variable whose value is to be used for an AND operation
  */
-#define atomicAndFetch16(memory, value) __atomic_and_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchAnd16(memory, value) __atomic_fetch_and(memory, value, __ATOMIC_SEQ_CST)
 /**
  * @brief Atomically performs AND operation to the variable that memory points to.
- * @return The resulting value of the AND operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the AND operation is to be performed
  * @param value variable whose value is to be used for an AND operation
  */
-#define atomicAndFetch32(memory, value) __atomic_and_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchAnd32(memory, value) __atomic_fetch_and(memory, value, __ATOMIC_SEQ_CST)
 /**
  * @brief Atomically performs AND operation to the variable that memory points to.
- * @return The resulting value of the AND operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the AND operation is to be performed
  * @param value variable whose value is to be used for an AND operation
  */
-#define atomicAndFetch64(memory, value) __atomic_and_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchAnd64(memory, value) __atomic_fetch_and(memory, value, __ATOMIC_SEQ_CST)
 
 /***********************************************************************************************************************
  * @brief Atomically performs OR operation to the variable that memory points to.
- * @return The resulting value of the OR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the OR operation is to be performed
  * @param value variable whose value is to be used for an OR operation
  */
-#define atomicOrFetch8(memory, value) __atomic_or_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchOr8(memory, value) __atomic_fetch_or(memory, value, __ATOMIC_SEQ_CST)
 /**
  * @brief Atomically performs OR operation to the variable that memory points to.
- * @return The resulting value of the OR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the OR operation is to be performed
  * @param value variable whose value is to be used for an OR operation
  */
-#define atomicOrFetch16(memory, value) __atomic_or_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchOr16(memory, value) __atomic_fetch_or(memory, value, __ATOMIC_SEQ_CST)
 /**
  * @brief Atomically performs OR operation to the variable that memory points to.
- * @return The resulting value of the OR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the OR operation is to be performed
  * @param value variable whose value is to be used for an OR operation
  */
-#define atomicOrFetch32(memory, value) __atomic_or_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchOr32(memory, value) __atomic_fetch_or(memory, value, __ATOMIC_SEQ_CST)
 /**
  * @brief Atomically performs OR operation to the variable that memory points to.
- * @return The resulting value of the OR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the OR operation is to be performed
  * @param value variable whose value is to be used for an OR operation
  */
-#define atomicOrFetch64(memory, value) __atomic_or_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchOr64(memory, value) __atomic_fetch_or(memory, value, __ATOMIC_SEQ_CST)
 
 /***********************************************************************************************************************
  * @brief Atomically performs XOR operation to the variable that memory points to.
- * @return The resulting value of the XOR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the XOR operation is to be performed
  * @param value variable whose value is to be used for an XOR operation
  */
-#define atomicXorFetch8(memory, value) __atomic_xor_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchXor8(memory, value) __atomic_fetch_xor(memory, value, __ATOMIC_SEQ_CST)
 /**
  * @brief Atomically performs XOR operation to the variable that memory points to.
- * @return The resulting value of the XOR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the XOR operation is to be performed
  * @param value variable whose value is to be used for an XOR operation
  */
-#define atomicXorFetch16(memory, value) __atomic_xor_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchXor16(memory, value) __atomic_fetch_xor(memory, value, __ATOMIC_SEQ_CST)
 /**
  * @brief Atomically performs XOR operation to the variable that memory points to.
- * @return The resulting value of the XOR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the XOR operation is to be performed
  * @param value variable whose value is to be used for an XOR operation
  */
-#define atomicXorFetch32(memory, value) __atomic_xor_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchXor32(memory, value) __atomic_fetch_xor(memory, value, __ATOMIC_SEQ_CST)
 /**
  * @brief Atomically performs XOR operation to the variable that memory points to.
- * @return The resulting value of the XOR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the XOR operation is to be performed
  * @param value variable whose value is to be used for an XOR operation
  */
-#define atomicXorFetch64(memory, value) __atomic_xor_fetch(memory, value, __ATOMIC_SEQ_CST)
+#define atomicFetchXor64(memory, value) __atomic_fetch_xor(memory, value, __ATOMIC_SEQ_CST)
 
 /***********************************************************************************************************************
  * @brief Atomically adds the value to the variable that memory points to.
@@ -411,102 +412,102 @@ static inline void atomicStore64(atomic_int64* memory, atomic_int64 value)
 
 /***********************************************************************************************************************
  * @brief Atomically performs AND operation to the variable that memory points to.
- * @return The resulting value of the AND operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the AND operation is to be performed
  * @param value variable whose value is to be used for an AND operation
  */
-#define atomicAndFetch8(memory, value) _InterlockedAnd8(memory, value)
+#define atomicFetchAnd8(memory, value) _InterlockedAnd8(memory, value)
 /**
  * @brief Atomically performs AND operation to the variable that memory points to.
- * @return The resulting value of the AND operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the AND operation is to be performed
  * @param value variable whose value is to be used for an AND operation
  */
-#define atomicAndFetch16(memory, value) _InterlockedAnd16(memory, value)
+#define atomicFetchAnd16(memory, value) _InterlockedAnd16(memory, value)
 /**
  * @brief Atomically performs AND operation to the variable that memory points to.
- * @return The resulting value of the AND operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the AND operation is to be performed
  * @param value variable whose value is to be used for an AND operation
  */
-#define atomicAndFetch32(memory, value) _InterlockedAnd(memory, value)
+#define atomicFetchAnd32(memory, value) _InterlockedAnd(memory, value)
 /**
  * @brief Atomically performs AND operation to the variable that memory points to.
- * @return The resulting value of the AND operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the AND operation is to be performed
  * @param value variable whose value is to be used for an AND operation
  */
-#define atomicAndFetch64(memory, value) _InterlockedAnd64(memory, value)
+#define atomicFetchAnd64(memory, value) _InterlockedAnd64(memory, value)
 
 /***********************************************************************************************************************
  * @brief Atomically performs OR operation to the variable that memory points to.
- * @return The resulting value of the OR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the OR operation is to be performed
  * @param value variable whose value is to be used for an OR operation
  */
-#define atomicOrFetch8(memory, value) _InterlockedOr8(memory, value)
+#define atomicFetchOr8(memory, value) _InterlockedOr8(memory, value)
 /**
  * @brief Atomically performs OR operation to the variable that memory points to.
- * @return The resulting value of the OR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the OR operation is to be performed
  * @param value variable whose value is to be used for an OR operation
  */
-#define atomicOrFetch16(memory, value) _InterlockedOr16(memory, value)
+#define atomicFetchOr16(memory, value) _InterlockedOr16(memory, value)
 /**
  * @brief Atomically performs OR operation to the variable that memory points to.
- * @return The resulting value of the OR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the OR operation is to be performed
  * @param value variable whose value is to be used for an OR operation
  */
-#define atomicOrFetch32(memory, value) _InterlockedOr(memory, value)
+#define atomicFetchOr32(memory, value) _InterlockedOr(memory, value)
 /**
  * @brief Atomically performs OR operation to the variable that memory points to.
- * @return The resulting value of the OR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the OR operation is to be performed
  * @param value variable whose value is to be used for an OR operation
  */
-#define atomicOrFetch64(memory, value) _InterlockedOr64(memory, value)
+#define atomicFetchOr64(memory, value) _InterlockedOr64(memory, value)
 
 /***********************************************************************************************************************
  * @brief Atomically performs XOR operation to the variable that memory points to.
- * @return The resulting value of the XOR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the XOR operation is to be performed
  * @param value variable whose value is to be used for an XOR operation
  */
-#define atomicXorFetch8(memory, value) _InterlockedXor8(memory, value)
+#define atomicFetchXor8(memory, value) _InterlockedXor8(memory, value)
 /**
  * @brief Atomically performs XOR operation to the variable that memory points to.
- * @return The resulting value of the XOR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the XOR operation is to be performed
  * @param value variable whose value is to be used for an XOR operation
  */
-#define atomicXorFetch16(memory, value) _InterlockedXor16(memory, value)
+#define atomicFetchXor16(memory, value) _InterlockedXor16(memory, value)
 /**
  * @brief Atomically performs XOR operation to the variable that memory points to.
- * @return The resulting value of the XOR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the XOR operation is to be performed
  * @param value variable whose value is to be used for an XOR operation
  */
-#define atomicXorFetch32(memory, value) _InterlockedXor(memory, value)
+#define atomicFetchXor32(memory, value) _InterlockedXor(memory, value)
 /**
  * @brief Atomically performs XOR operation to the variable that memory points to.
- * @return The resulting value of the XOR operation.
+ * @return The current value of the variable that memory points to.
  *
  * @param[in,out] memory pointer of a variable to which the XOR operation is to be performed
  * @param value variable whose value is to be used for an XOR operation
  */
-#define atomicXorFetch64(memory, value) _InterlockedXor64(memory, value)
+#define atomicFetchXor64(memory, value) _InterlockedXor64(memory, value)
 
 /***********************************************************************************************************************
  * @brief Atomically adds the value to the variable that memory points to.

tests/test_atomic.c

@@ -18,14 +18,17 @@
 
 int main()
 {
-	atomic_int32 value32 = 0; atomic_int64 value64 = 0;
-	atomicStore32(&value32, 123); atomicStore64(&value64, 456);
-	bool result = value32 == 123 && value64 == 456;
-	result &= atomicLoad32(&value32) == 123 && atomicLoad64(&value64) == 456;
-	result &= atomicFetchAdd32(&value32, 1) == 123 && atomicFetchAdd64(&value64, 1) == 456;
-	result &= value32 == 124 && value64 == 457;
-	result &= atomicExchange32(&value32, 0) == 124 && atomicExchange64(&value64, 0) == 457;
-	result &= atomicOrFetch32(&value32, 111) == 111 && atomicOrFetch64(&value64, 2222) == 2222;
-	result &= atomicAndFetch32(&value32, 1) == 1 && atomicAndFetch64(&value64, 0) == 0;
+	atomic_int32* value32 = calloc(1, sizeof(atomic_int32));
+	atomic_int64* value64 = calloc(1, sizeof(atomic_int64));
+	atomicStore32(value32, 123); atomicStore64(value64, 456);
+	bool result = atomicLoad32(value32) == 123 && atomicLoad64(value64) == 456;
+	result &= atomicLoad32(value32) == 123 && atomicLoad64(value64) == 456;
+	result &= atomicFetchAdd32(value32, 1) == 123 && atomicFetchAdd64(value64, 1) == 456;
+	result &= atomicLoad32(value32) == 124 && atomicLoad64(value64) == 457;
+	result &= atomicExchange32(value32, 0) == 124 && atomicExchange64(value64, 0) == 457;
+	atomicFetchOr32(value32, 111); atomicFetchOr64(value64, 2222);
+	result &= atomicLoad32(value32) == 111 && atomicLoad64(value64) == 2222;
+	atomicFetchAnd32(value32, 1); atomicFetchAnd64(value64, 0);
+	result &= atomicLoad32(value32) == 1 && atomicLoad64(value64) == 0;
 	return result ? EXIT_SUCCESS : EXIT_FAILURE;
-}
+}