Skip to content

Commit

Permalink
Fixed clang tidy warnings
Browse files Browse the repository at this point in the history
  • Loading branch information
@shuhaowu
shuhaowu committed Jul 13, 2024
1 parent fce49c8 commit e4e83f4
Show file tree
Hide file tree
Showing 5 changed files with 92 additions and 97 deletions.
16 changes: 8 additions & 8 deletions include/cactus_rt/experimental/lockless/atomic_bitset.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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<size_t> indices, const std::memory_order order = std::memory_order_seq_cst);
void SetRange(std::initializer_list<size_t> 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<size_t> indices, const std::memory_order order = std::memory_order_seq_cst);
void ResetRange(std::initializer_list<size_t> 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<size_t> indices, const std::memory_order order = std::memory_order_seq_cst);
void FlipRange(std::initializer_list<size_t> 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);
Expand Down
25 changes: 10 additions & 15 deletions src/cactus_rt/experimental/lockless/atomic_bitset.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,15 +7,16 @@ template <typename T>
void AtomicBitset<T>::Set(const size_t i, const std::memory_order order) {
assert(i < kCapacity);

T bitmask = kOne << i;
T bitmask = kOne << static_cast<T>(i);
data_.fetch_or(bitmask, order);
}

template <typename T>
void AtomicBitset<T>::SetRange(const std::initializer_list<size_t> indices, const std::memory_order order) {
T bitmask = 0;
for (const auto i : indices) {
bitmask |= (kOne << i);
assert(i < kCapacity);
bitmask |= (kOne << static_cast<T>(i));
}

data_.fetch_or(bitmask, order);
Expand All @@ -25,15 +26,16 @@ template <typename T>
void AtomicBitset<T>::Reset(const size_t i, const std::memory_order order) {
assert(i < kCapacity);

T bitmask = ~(kOne << i);
T bitmask = ~(kOne << static_cast<T>(i));
data_.fetch_and(bitmask, order);
}

template <typename T>
void AtomicBitset<T>::ResetRange(const std::initializer_list<size_t> indices, const std::memory_order order) {
T bitmask = 0;
for (const auto i : indices) {
bitmask |= (kOne << i);
assert(i < kCapacity);
bitmask |= (kOne << static_cast<T>(i));
}

bitmask = ~(bitmask);
Expand All @@ -44,15 +46,16 @@ template <typename T>
void AtomicBitset<T>::Flip(const size_t i, const std::memory_order order) {
assert(i < kCapacity);

T bitmask = kOne << i;
T bitmask = kOne << static_cast<T>(i);
data_.fetch_xor(bitmask, order);
}

template <typename T>
void AtomicBitset<T>::FlipRange(const std::initializer_list<size_t> indices, const std::memory_order order) {
T bitmask = 0;
for (const auto i : indices) {
bitmask |= (kOne << i);
assert(i < kCapacity);
bitmask |= (kOne << static_cast<T>(i));
}

data_.fetch_xor(bitmask, order);
Expand All @@ -73,7 +76,7 @@ template <typename T>
bool AtomicBitset<T>::Test(const size_t i, const std::memory_order order) const {
assert(i < kCapacity);

T bitmask = kOne << i;
T bitmask = kOne << static_cast<T>(i);
return data_.load(order) & bitmask;
}

Expand All @@ -89,12 +92,4 @@ template class AtomicBitset<unsigned long>;
template class AtomicBitset<unsigned int>;
#endif

#if (ATOMIC_SHORT_LOCK_FREE == 2)
template class AtomicBitset<unsigned short>;
#endif

#if (ATOMIC_CHAR_LOCK_FREE == 2)
template class AtomicBitset<unsigned char>;
#endif

} // namespace cactus_rt::experimental::lockless
116 changes: 58 additions & 58 deletions tests/experimental/lockless/atomic_bitset_test.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,128 +2,128 @@

#include <gtest/gtest.h>

using AtomicBitset8 = cactus_rt::experimental::lockless::AtomicBitset<uint8_t>;
using AtomicBitset32 = cactus_rt::experimental::lockless::AtomicBitset<uint32_t>;
using AtomicBitset64 = cactus_rt::experimental::lockless::AtomicBitset<uint64_t>;

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), "");
AtomicBitset32 bitset32;
EXPECT_DEATH(bitset32.Set(32), "");

AtomicBitset64 bitset64;
bitset64.Set(8);
Expand All @@ -132,5 +132,5 @@ TEST(AtomicBitsetTest, OutOfRange) {
EXPECT_EQ(bitset64[i], i == 8);
}

EXPECT_DEATH(bitset8.Set(64), "");
EXPECT_DEATH(bitset32.Set(64), "");
}
16 changes: 8 additions & 8 deletions tests/experimental/lockless/spsc/realtime_readable_value_test.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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<Data>;
Expand All @@ -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);
}
Loading

0 comments on commit e4e83f4

Please sign in to comment.