text
stringlengths 0
2.2M
|
|---|
runWritesNeverFail<std::atomic>(10, 100, 4);
|
runWritesNeverFail<std::atomic>(100, 1000, 8);
|
runWritesNeverFail<std::atomic>(1000, 10000, 16);
|
runWritesNeverFail<EmulatedFutexAtomic>(1, 100, 4);
|
runWritesNeverFail<EmulatedFutexAtomic>(10, 100, 4);
|
runWritesNeverFail<EmulatedFutexAtomic>(100, 1000, 8);
|
runWritesNeverFail<EmulatedFutexAtomic>(1000, 10000, 16);
|
}
|
TEST(LockFreeRingBuffer, readerCanDetectSkips) {
|
const int capacity = 4;
|
const int rounds = 4;
|
LockFreeRingBuffer<int> rb(capacity);
|
auto cursor = rb.currentHead();
|
cursor.moveForward(1);
|
for (int round = 0; round < rounds; round++) {
|
for (int i = 0; i < capacity; i++) {
|
int val = round * capacity + i;
|
rb.write(val);
|
}
|
}
|
int result = -1;
|
EXPECT_FALSE(rb.tryRead(result, cursor));
|
EXPECT_FALSE(rb.waitAndTryRead(result, cursor));
|
EXPECT_EQ(-1, result);
|
cursor = rb.currentTail();
|
EXPECT_TRUE(rb.tryRead(result, cursor));
|
EXPECT_EQ(capacity * (rounds - 1), result);
|
}
|
TEST(LockFreeRingBuffer, cursorFromWrites) {
|
const int capacity = 3;
|
LockFreeRingBuffer<int> rb(capacity);
|
// Workaround for template deduction failure
|
auto (&cursorValue)(value<int, std::atomic>);
|
int val = 0xfaceb00c;
|
EXPECT_EQ(0, cursorValue(rb.writeAndGetCursor(val)));
|
EXPECT_EQ(1, cursorValue(rb.writeAndGetCursor(val)));
|
EXPECT_EQ(2, cursorValue(rb.writeAndGetCursor(val)));
|
// Check that rb is giving out actual cursors and not just
|
// pointing to the current slot.
|
EXPECT_EQ(3, cursorValue(rb.writeAndGetCursor(val)));
|
}
|
TEST(LockFreeRingBuffer, moveBackwardsCanFail) {
|
const int capacity = 3;
|
LockFreeRingBuffer<int> rb(capacity);
|
// Workaround for template deduction failure
|
auto (&cursorValue)(value<int, std::atomic>);
|
int val = 0xfaceb00c;
|
rb.write(val);
|
rb.write(val);
|
auto cursor = rb.currentHead(); // points to 2
|
EXPECT_EQ(2, cursorValue(cursor));
|
EXPECT_TRUE(cursor.moveBackward());
|
EXPECT_TRUE(cursor.moveBackward()); // now at 0
|
EXPECT_FALSE(cursor.moveBackward()); // moving back does nothing
|
}
|
namespace {
|
struct S {
|
int x;
|
float y;
|
char c;
|
};
|
} // namespace
|
TEST(LockFreeRingBuffer, contendedReadsAndWrites) {
|
LockFreeRingBuffer<S> rb{2};
|
std::atomic<bool> done{false};
|
std::vector<std::thread> threads;
|
for (int i = 0; i < 8; ++i) {
|
threads.emplace_back([&] {
|
while (!done.load(std::memory_order_relaxed)) {
|
S value{10, -5.5, 100};
|
rb.write(value);
|
}
|
});
|
}
|
for (int i = 0; i < 8; ++i) {
|
threads.emplace_back([&] {
|
S value;
|
while (!done.load(std::memory_order_relaxed)) {
|
if (rb.tryRead(value, rb.currentTail())) {
|
EXPECT_EQ(10, value.x);
|
EXPECT_EQ(-5.5, value.y);
|
Subsets and Splits