Testing SC-DRF non-atomic global read and write within a locked mutex critical block.
Testing SC-DRF non-atomic global read and write within a locked mutex critical block.
#include <cassert>
#include <cinttypes>
#include <cstring>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <memory>
#include <thread>
#include <pthread.h>
private:
enum Defaults : int {
array_size = 10
};
constexpr int number(const Defaults rhs) noexcept {
return static_cast<int>(rhs);
}
int value1 = 0;
int array[array_size] = { 0 };
std::mutex mtx_value;
std::condition_variable cvRead;
std::condition_variable cvWrite;
void reset(int v1, int array_value) {
std::unique_lock<std::mutex> lock(mtx_value);
value1 = v1;
for(int & i : array) {
i = array_value;
}
}
void putThreadType01(int _len, int startValue) {
const int len =
std::min(number(array_size), _len);
{
std::unique_lock<std::mutex> lock(mtx_value);
for(int i=0; i<len; i++) {
array[i] = startValue+i;
}
value1 = startValue;
cvRead.notify_all();
}
}
void getThreadType01(const std::string& msg, int _len, int startValue) {
const int len =
std::min(number(array_size), _len);
std::unique_lock<std::mutex> lock(mtx_value);
while( startValue != value1 ) {
cvRead.wait(lock);
}
REQUIRE_MSG(msg+
": %s: value at read value1 (start)", startValue == value1);
for(int i=0; i<len; i++) {
int v = array[i];
}
}
void putThreadType11(int indexAndValue) {
const int idx =
std::min(number(array_size)-1, indexAndValue);
{
std::unique_lock<std::mutex> lock(mtx_value);
while( idx != (value1 * -1) - 1 ) {
cvWrite.wait(lock);
}
value1 = idx;
array[idx] = idx;
cvRead.notify_all();
}
}
void getThreadType11(const std::string& msg, int _idx) {
const int idx =
std::min(number(array_size)-1, _idx);
std::unique_lock<std::mutex> lock(mtx_value);
while( idx != value1 ) {
cvRead.wait(lock);
}
int next_idx = (idx+1)%array_size;
next_idx = ( next_idx + 1 ) * -1;
value1 = next_idx;
cvWrite.notify_all();
}
public:
: value1(0) {}
reset(0, 1010);
std::thread getThread01(&TestMemModelSCDRF01::getThreadType01, this, "test01.get01", array_size, 3);
std::thread putThread01(&TestMemModelSCDRF01::putThreadType01, this, array_size, 3);
putThread01.join();
getThread01.join();
}
reset(0, 1021);
{
std::thread getThread00(&TestMemModelSCDRF01::getThreadType01, this, "test01.get00", array_size, 4);
std::thread getThread01(&TestMemModelSCDRF01::getThreadType01, this, "test01.get01", array_size, 4);
std::thread putThread01(&TestMemModelSCDRF01::putThreadType01, this, array_size, 4);
putThread01.join();
getThread00.join();
getThread01.join();
}
reset(0, 1022);
{
std::thread putThread01(&TestMemModelSCDRF01::putThreadType01, this, array_size, 5);
std::thread getThread00(&TestMemModelSCDRF01::getThreadType01, this, "test01.get00", array_size, 5);
std::thread getThread01(&TestMemModelSCDRF01::getThreadType01, this, "test01.get01", array_size, 5);
putThread01.join();
getThread00.join();
getThread01.join();
}
}
reset(0, 1030);
std::thread getThread01(&TestMemModelSCDRF01::getThreadType01, this, "test02.get01", array_size, 6);
std::thread getThread02(&TestMemModelSCDRF01::getThreadType01, this, "test02.get02", array_size, 6);
std::thread putThread01(&TestMemModelSCDRF01::putThreadType01, this, array_size, 6);
std::thread getThread03(&TestMemModelSCDRF01::getThreadType01, this, "test02.get03", array_size, 6);
std::thread getThread04(&TestMemModelSCDRF01::getThreadType01, this, "test02.get04", array_size, 6);
putThread01.join();
getThread01.join();
getThread02.join();
getThread03.join();
getThread04.join();
}
reset(-1, 1110);
std::thread reader[array_size];
std::thread writer[array_size];
for(int i=0; i<number(array_size); i++) {
reader[i] = std::thread(&TestMemModelSCDRF01::getThreadType11, this, "test11.get11", i);
}
for(int i=0; i<number(array_size); i++) {
writer[i] = std::thread(&TestMemModelSCDRF01::putThreadType11, this, i);
}
for(int i=0; i<number(array_size); i++) {
writer[i].join();
}
for(int i=0; i<number(array_size); i++) {
reader[i].join();
}
}
reset(-1, 1120);
std::thread reader[array_size];
std::thread writer[array_size];
for(int i=0; i<number(array_size); i++) {
writer[i] = std::thread(&TestMemModelSCDRF01::putThreadType11, this, i);
}
for(int i=0; i<number(array_size); i++) {
reader[i] = std::thread(&TestMemModelSCDRF01::getThreadType11, this, "test12.get11", i);
}
for(int i=0; i<number(array_size); i++) {
writer[i].join();
}
for(int i=0; i<number(array_size); i++) {
reader[i].join();
}
}
}
};
#define REQUIRE_MSG(MSG,...)
test_mm_sc_drf_01: Testing SC-DRF non-atomic global read and write within a locked mutex critical blo...
void test12_Read10Write10()
void test03_Read4Write1()
void test01_Read1Write1()
void test11_Read10Write10()
void test02_Read2Write1()
std::string to_string(const alphabet &v) noexcept
constexpr T min(const T x, const T y) noexcept
Returns the minimum of two integrals (w/ branching) in O(1)
__pack(...): Produces MSVC, clang and gcc compatible lead-in and -out macros.
METHOD_AS_TEST_CASE(TestMemModelSCDRF01::test_list, "Test TestMemModelSCDRF 01- test_list")