From 29b4db0ae80a786330c5125bdbf0bf680f6d7d56 Mon Sep 17 00:00:00 2001 From: Shuhao Wu Date: Fri, 12 Jul 2024 22:20:23 -0400 Subject: [PATCH] Fixed clang tidy warnings --- examples/lockless_example/main.cc | 4 +- .../experimental/lockless/atomic_bitset.h | 16 +-- .../experimental/lockless/atomic_bitset.cc | 25 ++-- tests/CMakeLists.txt | 5 + .../lockless/atomic_bitset_test.cc | 120 +++++++++--------- .../spsc/realtime_readable_value_test.cc | 16 +-- .../spsc/realtime_writable_value_test.cc | 16 +-- 7 files changed, 103 insertions(+), 99 deletions(-) diff --git a/examples/lockless_example/main.cc b/examples/lockless_example/main.cc index 78e69d7..1cccae4 100644 --- a/examples/lockless_example/main.cc +++ b/examples/lockless_example/main.cc @@ -24,7 +24,7 @@ struct Pose { double pitch = 0.0; double yaw = 0.0; - Pose() {} + Pose() = default; Pose(double xx, double yy, double zz, double ro, double pi, double ya) : valid(true), x(xx), @@ -81,7 +81,7 @@ class RTThread : public CyclicThread { return true; } - Pose new_pose = ctx_.target_pose.Read(); + const Pose new_pose = ctx_.target_pose.Read(); if (!new_pose.valid) { return false; } diff --git a/include/cactus_rt/experimental/lockless/atomic_bitset.h b/include/cactus_rt/experimental/lockless/atomic_bitset.h index 6badde3..4a26a4c 100644 --- a/include/cactus_rt/experimental/lockless/atomic_bitset.h +++ b/include/cactus_rt/experimental/lockless/atomic_bitset.h @@ -24,21 +24,21 @@ class AtomicBitset { */ AtomicBitset() : data_(0) {} - void Set(const size_t i, const std::memory_order order = std::memory_order_seq_cst); + void Set(size_t i, std::memory_order order = std::memory_order_seq_cst); - void SetRange(const std::initializer_list indices, const std::memory_order order = std::memory_order_seq_cst); + void SetRange(std::initializer_list indices, std::memory_order order = std::memory_order_seq_cst); - void Reset(const size_t i, const std::memory_order order = std::memory_order_seq_cst); + void Reset(size_t i, std::memory_order order = std::memory_order_seq_cst); - void ResetRange(const std::initializer_list indices, const std::memory_order order = std::memory_order_seq_cst); + void ResetRange(std::initializer_list indices, std::memory_order order = std::memory_order_seq_cst); - void Flip(const size_t t, const std::memory_order order = std::memory_order_seq_cst); + void Flip(size_t i, std::memory_order order = std::memory_order_seq_cst); - void FlipRange(const std::initializer_list indices, const std::memory_order order = std::memory_order_seq_cst); + void FlipRange(std::initializer_list indices, std::memory_order order = std::memory_order_seq_cst); - void SetValue(const size_t i, const bool value, const std::memory_order order = std::memory_order_seq_cst); + void SetValue(size_t i, bool value, std::memory_order order = std::memory_order_seq_cst); - bool Test(const size_t i, const std::memory_order order = std::memory_order_seq_cst) const; + bool Test(size_t i, std::memory_order order = std::memory_order_seq_cst) const; T Value(const std::memory_order order = std::memory_order_seq_cst) const { return data_.load(order); diff --git a/src/cactus_rt/experimental/lockless/atomic_bitset.cc b/src/cactus_rt/experimental/lockless/atomic_bitset.cc index ce9f115..a738954 100644 --- a/src/cactus_rt/experimental/lockless/atomic_bitset.cc +++ b/src/cactus_rt/experimental/lockless/atomic_bitset.cc @@ -7,7 +7,7 @@ template void AtomicBitset::Set(const size_t i, const std::memory_order order) { assert(i < kCapacity); - T bitmask = kOne << i; + T bitmask = kOne << static_cast(i); data_.fetch_or(bitmask, order); } @@ -15,7 +15,8 @@ template void AtomicBitset::SetRange(const std::initializer_list indices, const std::memory_order order) { T bitmask = 0; for (const auto i : indices) { - bitmask |= (kOne << i); + assert(i < kCapacity); + bitmask |= (kOne << static_cast(i)); } data_.fetch_or(bitmask, order); @@ -25,7 +26,7 @@ template void AtomicBitset::Reset(const size_t i, const std::memory_order order) { assert(i < kCapacity); - T bitmask = ~(kOne << i); + T bitmask = ~(kOne << static_cast(i)); data_.fetch_and(bitmask, order); } @@ -33,7 +34,8 @@ template void AtomicBitset::ResetRange(const std::initializer_list indices, const std::memory_order order) { T bitmask = 0; for (const auto i : indices) { - bitmask |= (kOne << i); + assert(i < kCapacity); + bitmask |= (kOne << static_cast(i)); } bitmask = ~(bitmask); @@ -44,7 +46,7 @@ template void AtomicBitset::Flip(const size_t i, const std::memory_order order) { assert(i < kCapacity); - T bitmask = kOne << i; + T bitmask = kOne << static_cast(i); data_.fetch_xor(bitmask, order); } @@ -52,7 +54,8 @@ template void AtomicBitset::FlipRange(const std::initializer_list indices, const std::memory_order order) { T bitmask = 0; for (const auto i : indices) { - bitmask |= (kOne << i); + assert(i < kCapacity); + bitmask |= (kOne << static_cast(i)); } data_.fetch_xor(bitmask, order); @@ -73,7 +76,7 @@ template bool AtomicBitset::Test(const size_t i, const std::memory_order order) const { assert(i < kCapacity); - T bitmask = kOne << i; + T bitmask = kOne << static_cast(i); return data_.load(order) & bitmask; } @@ -89,12 +92,4 @@ template class AtomicBitset; template class AtomicBitset; #endif -#if (ATOMIC_SHORT_LOCK_FREE == 2) -template class AtomicBitset; -#endif - -#if (ATOMIC_CHAR_LOCK_FREE == 2) -template class AtomicBitset; -#endif - } // namespace cactus_rt::experimental::lockless diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index ebd17e9..d777f62 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -18,6 +18,11 @@ target_link_libraries(cactus_rt_tests setup_cactus_rt_target_options(cactus_rt_tests) +target_compile_definitions(cactus_rt_tests + PRIVATE + CMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" +) + gtest_discover_tests(cactus_rt_tests) if(ENABLE_TRACING) diff --git a/tests/experimental/lockless/atomic_bitset_test.cc b/tests/experimental/lockless/atomic_bitset_test.cc index 87a8911..cdc0ccd 100644 --- a/tests/experimental/lockless/atomic_bitset_test.cc +++ b/tests/experimental/lockless/atomic_bitset_test.cc @@ -2,128 +2,132 @@ #include -using AtomicBitset8 = cactus_rt::experimental::lockless::AtomicBitset; +using AtomicBitset32 = cactus_rt::experimental::lockless::AtomicBitset; using AtomicBitset64 = cactus_rt::experimental::lockless::AtomicBitset; TEST(AtomicBitsetTest, SetResetAndLoad) { - AtomicBitset8 bitset8; + AtomicBitset32 bitset32; - for (size_t i = 0; i < 8; i++) { - EXPECT_FALSE(bitset8.Test(i)); + for (size_t i = 0; i < 32; i++) { + EXPECT_FALSE(bitset32.Test(i)); } - bitset8.Set(0); + bitset32.Set(0); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), i == 0); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), i == 0); } - bitset8.Set(2); + bitset32.Set(2); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), i == 0 || i == 2); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), i == 0 || i == 2); } - bitset8.Set(7); + bitset32.Set(7); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), i == 0 || i == 2 || i == 7); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), i == 0 || i == 2 || i == 7); } - bitset8.Reset(7); + bitset32.Reset(7); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8[i], i == 0 || i == 2); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32[i], i == 0 || i == 2); } - bitset8.Reset(6); + bitset32.Reset(6); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), i == 0 || i == 2); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), i == 0 || i == 2); } - bitset8.Reset(0); + bitset32.Reset(0); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), i == 2); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), i == 2); } } TEST(AtomicBitsetTest, SetRangeResetRangeAndTest) { - AtomicBitset8 bitset8; + AtomicBitset32 bitset32; - bitset8.SetRange({1, 6}); + bitset32.SetRange({1, 6}); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), (i == 1) || (i == 6)); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), (i == 1) || (i == 6)); } - bitset8.ResetRange({1, 2}); + bitset32.ResetRange({1, 2}); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), i == 6); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), i == 6); } - bitset8.SetRange({2, 6}); + bitset32.SetRange({2, 6}); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), (i == 2) || (i == 6)); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), (i == 2) || (i == 6)); } - bitset8.ResetRange({1, 2, 6}); + bitset32.ResetRange({1, 2, 6}); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), false); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), false); } } TEST(AtomicBitsetTest, FlipAndTest) { - AtomicBitset8 bitset8; + AtomicBitset32 bitset32; - bitset8.Flip(2); + bitset32.Flip(2); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), i == 2); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), i == 2); } - bitset8.FlipRange({2, 3, 7}); + bitset32.FlipRange({2, 3, 7}); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8[i], (i == 3) || (i == 7)); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32[i], (i == 3) || (i == 7)); } - bitset8.Flip(2); + bitset32.Flip(2); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8[i], (i == 2) || (i == 3) || (i == 7)); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32[i], (i == 2) || (i == 3) || (i == 7)); } } TEST(AtomicBitsetTest, SetValueAndTest) { - AtomicBitset8 bitset8; + AtomicBitset32 bitset32; - bitset8.SetValue(2, true); + bitset32.SetValue(2, true); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8.Test(i), i == 2); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32.Test(i), i == 2); } - bitset8.SetValue(2, false); + bitset32.SetValue(2, false); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8[i], false); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32[i], false); } - bitset8.SetValue(2, false); + bitset32.SetValue(2, false); - for (size_t i = 0; i < 8; i++) { - EXPECT_EQ(bitset8[i], false); + for (size_t i = 0; i < 32; i++) { + EXPECT_EQ(bitset32[i], false); } } TEST(AtomicBitsetTest, OutOfRange) { - AtomicBitset8 bitset8; - EXPECT_DEATH(bitset8.Set(8), ""); +#if (CMAKE_BUILD_TYPE == RelWithDebInfo && CMAKE_BUILD_TYPE == Release) + GTEST_SKIP(); // won't die in release build +#endif + + AtomicBitset32 bitset32; + EXPECT_DEATH(bitset32.Set(32), ""); AtomicBitset64 bitset64; bitset64.Set(8); @@ -132,5 +136,5 @@ TEST(AtomicBitsetTest, OutOfRange) { EXPECT_EQ(bitset64[i], i == 8); } - EXPECT_DEATH(bitset8.Set(64), ""); + EXPECT_DEATH(bitset32.Set(64), ""); } diff --git a/tests/experimental/lockless/spsc/realtime_readable_value_test.cc b/tests/experimental/lockless/spsc/realtime_readable_value_test.cc index 6b34073..d8b0767 100644 --- a/tests/experimental/lockless/spsc/realtime_readable_value_test.cc +++ b/tests/experimental/lockless/spsc/realtime_readable_value_test.cc @@ -5,7 +5,7 @@ struct Data { int a = 1; double b = 2.0; - float c = 3.0f; + float c = 3.0F; }; using RealtimeReadableData = cactus_rt::experimental::lockless::spsc::RealtimeReadableValue; @@ -20,34 +20,34 @@ TEST(RealtimeReadableValueTest, ReadAndWrite) { auto data1 = data.Read(); EXPECT_EQ(data1.a, 1); EXPECT_EQ(data1.b, 2.0); - EXPECT_EQ(data1.c, 3.0f); + EXPECT_EQ(data1.c, 3.0F); // Initial write - Data new_data{2, 3.0, 4.0f}; + const Data new_data{2, 3.0, 4.0F}; data.Write(new_data); // Read after write auto data2 = data.Read(); EXPECT_EQ(data2.a, 2); EXPECT_EQ(data2.b, 3.0); - EXPECT_EQ(data2.c, 4.0f); + EXPECT_EQ(data2.c, 4.0F); // Read again auto data3 = data.Read(); EXPECT_EQ(data3.a, 2); EXPECT_EQ(data3.b, 3.0); - EXPECT_EQ(data3.c, 4.0f); + EXPECT_EQ(data3.c, 4.0F); // Now write twice - Data new_data2{3, 4.0, 5.0f}; + const Data new_data2{3, 4.0, 5.0F}; data.Write(new_data2); - Data new_data3{4, 5.0, 6.0f}; + const Data new_data3{4, 5.0, 6.0F}; data.Write(new_data3); // Read again auto data4 = data.Read(); EXPECT_EQ(data4.a, 4); EXPECT_EQ(data4.b, 5.0); - EXPECT_EQ(data4.c, 6.0f); + EXPECT_EQ(data4.c, 6.0F); } diff --git a/tests/experimental/lockless/spsc/realtime_writable_value_test.cc b/tests/experimental/lockless/spsc/realtime_writable_value_test.cc index 80206a3..18e4954 100644 --- a/tests/experimental/lockless/spsc/realtime_writable_value_test.cc +++ b/tests/experimental/lockless/spsc/realtime_writable_value_test.cc @@ -5,7 +5,7 @@ struct Data { int a = 1; double b = 2.0; - float c = 3.0f; + float c = 3.0F; }; using RealtimeWritableData = cactus_rt::experimental::lockless::spsc::RealtimeWritableValue; @@ -20,34 +20,34 @@ TEST(RealtimeWritableValueTest, ReadAndWrite) { auto data1 = data.Read(); EXPECT_EQ(data1.a, 1); EXPECT_EQ(data1.b, 2.0); - EXPECT_EQ(data1.c, 3.0f); + EXPECT_EQ(data1.c, 3.0F); // Initial write - Data new_data{2, 3.0, 4.0f}; + const Data new_data{2, 3.0, 4.0F}; data.Write(new_data); // Read after write auto data2 = data.Read(); EXPECT_EQ(data2.a, 2); EXPECT_EQ(data2.b, 3.0); - EXPECT_EQ(data2.c, 4.0f); + EXPECT_EQ(data2.c, 4.0F); // Read again auto data3 = data.Read(); EXPECT_EQ(data3.a, 2); EXPECT_EQ(data3.b, 3.0); - EXPECT_EQ(data3.c, 4.0f); + EXPECT_EQ(data3.c, 4.0F); // Now write twice - Data new_data2{3, 4.0, 5.0f}; + const Data new_data2{3, 4.0, 5.0F}; data.Write(new_data2); - Data new_data3{4, 5.0, 6.0f}; + const Data new_data3{4, 5.0, 6.0F}; data.Write(new_data3); // Read again auto data4 = data.Read(); EXPECT_EQ(data4.a, 4); EXPECT_EQ(data4.b, 5.0); - EXPECT_EQ(data4.c, 6.0f); + EXPECT_EQ(data4.c, 6.0F); }