michaelh/zephyr
1
0
Fork 0
Code Releases Activity

tests: kernel: atomics: expand atomic operations to 64-bit

Browse source 
This change updates the atomic tests to validate 32-bits on
32-bit architectures and 64-bits on 64-bit architectures.

Signed-off-by: Christopher Friedt <chrisfriedt@gmail.com>
This commit is contained in:
Christopher Friedt 2021-10-26 14:16:05 -04:00 • committed by Anas Nashif
commit ed7eec4c94
1 changed files with 31 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

55
tests/kernel/common/src/atomic.c
View file

@ -7,6 +7,10 @@
#include <ztest.h> #include <ztest.h>
#include <sys/atomic.h> #include <sys/atomic.h>
/* convenience macro - return either 64-bit or 32-bit value */
#define ATOMIC_WORD(val_if_64, val_if_32) \
((atomic_t)((sizeof(void *) == sizeof(uint64_t)) ? (val_if_64) : (val_if_32)))
/* an example of the number of atomic bit in an array */ /* an example of the number of atomic bit in an array */
#define NUM_FLAG_BITS 100 #define NUM_FLAG_BITS 100
@ -102,6 +106,9 @@ void test_atomic(void)
ATOMIC_DEFINE(flag_bits, NUM_FLAG_BITS) = {0}; ATOMIC_DEFINE(flag_bits, NUM_FLAG_BITS) = {0};
zassert_equal(sizeof(atomic_t), ATOMIC_WORD(sizeof(uint64_t), sizeof(uint32_t)),
"sizeof(atomic_t)");
target = 4; target = 4;
value = 5; value = 5;
oldvalue = 6; oldvalue = 6;
@ -211,63 +218,63 @@ void test_atomic(void)
target = 0xFF00; target = 0xFF00;
value = 0x0F0F; value = 0x0F0F;
zassert_true((atomic_nand(&target, value) == 0xFF00), "atomic_nand"); zassert_true((atomic_nand(&target, value) == 0xFF00), "atomic_nand");
zassert_true((target == 0xFFFFF0FF), "atomic_nand"); zassert_true((target == ATOMIC_WORD(0xFFFFFFFFFFFFF0FF, 0xFFFFF0FF)), "atomic_nand");
/* atomic_test_bit() */ /* atomic_test_bit() */
for (i = 0; i < 32; i++) { for (i = 0; i < ATOMIC_BITS; i++) {
target = 0x0F0F0F0F; target = ATOMIC_WORD(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F);
zassert_true(!!(atomic_test_bit(&target, i) == !!(target & (1 << i))), zassert_true(!!(atomic_test_bit(&target, i) == !!(target & BIT(i))),
"atomic_test_bit"); "atomic_test_bit");
} }
/* atomic_test_and_clear_bit() */ /* atomic_test_and_clear_bit() */
for (i = 0; i < 32; i++) { for (i = 0; i < ATOMIC_BITS; i++) {
orig = 0x0F0F0F0F; orig = ATOMIC_WORD(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F);
target = orig; target = orig;
zassert_true(!!(atomic_test_and_clear_bit(&target, i)) == !!(orig & (1 << i)), zassert_true(!!(atomic_test_and_clear_bit(&target, i)) == !!(orig & BIT(i)),
"atomic_test_and_clear_bit"); "atomic_test_and_clear_bit");
zassert_true(target == (orig & ~(1 << i)), "atomic_test_and_clear_bit"); zassert_true(target == (orig & ~BIT(i)), "atomic_test_and_clear_bit");
} }
/* atomic_test_and_set_bit() */ /* atomic_test_and_set_bit() */
for (i = 0; i < 32; i++) { for (i = 0; i < ATOMIC_BITS; i++) {
orig = 0x0F0F0F0F; orig = ATOMIC_WORD(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F);
target = orig; target = orig;
zassert_true(!!(atomic_test_and_set_bit(&target, i)) == !!(orig & (1 << i)), zassert_true(!!(atomic_test_and_set_bit(&target, i)) == !!(orig & BIT(i)),
"atomic_test_and_set_bit"); "atomic_test_and_set_bit");
zassert_true(target == (orig | (1 << i)), "atomic_test_and_set_bit"); zassert_true(target == (orig | BIT(i)), "atomic_test_and_set_bit");
} }
/* atomic_clear_bit() */ /* atomic_clear_bit() */
for (i = 0; i < 32; i++) { for (i = 0; i < ATOMIC_BITS; i++) {
orig = 0x0F0F0F0F; orig = ATOMIC_WORD(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F);
target = orig; target = orig;
atomic_clear_bit(&target, i); atomic_clear_bit(&target, i);
zassert_true(target == (orig & ~(1 << i)), "atomic_clear_bit"); zassert_true(target == (orig & ~BIT(i)), "atomic_clear_bit");
} }
/* atomic_set_bit() */ /* atomic_set_bit() */
for (i = 0; i < 32; i++) { for (i = 0; i < ATOMIC_BITS; i++) {
orig = 0x0F0F0F0F; orig = ATOMIC_WORD(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F);
target = orig; target = orig;
atomic_set_bit(&target, i); atomic_set_bit(&target, i);
zassert_true(target == (orig | (1 << i)), "atomic_set_bit"); zassert_true(target == (orig | BIT(i)), "atomic_set_bit");
} }
/* atomic_set_bit_to(&target, i, false) */ /* atomic_set_bit_to(&target, i, false) */
for (i = 0; i < 32; i++) { for (i = 0; i < ATOMIC_BITS; i++) {
orig = 0x0F0F0F0F; orig = ATOMIC_WORD(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F);
target = orig; target = orig;
atomic_set_bit_to(&target, i, false); atomic_set_bit_to(&target, i, false);
zassert_true(target == (orig & ~(1 << i)), "atomic_set_bit_to"); zassert_true(target == (orig & ~BIT(i)), "atomic_set_bit_to");
} }
/* atomic_set_bit_to(&target, i, true) */ /* atomic_set_bit_to(&target, i, true) */
for (i = 0; i < 32; i++) { for (i = 0; i < ATOMIC_BITS; i++) {
orig = 0x0F0F0F0F; orig = ATOMIC_WORD(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F);
target = orig; target = orig;
atomic_set_bit_to(&target, i, true); atomic_set_bit_to(&target, i, true);
zassert_true(target == (orig | (1 << i)), "atomic_set_bit_to"); zassert_true(target == (orig | BIT(i)), "atomic_set_bit_to");
} }
/* ATOMIC_DEFINE */ /* ATOMIC_DEFINE */