Added RW Mutex
This commit is contained in:
WolverinDEV
parent
ae4751ee6f
commit
0d0d7dd192
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,5 +1,5 @@
|
||||
//
|
||||
// Created by WolverinDEV on 03/03/2020.
|
||||
//
|
||||
|
||||
#include "rw_mutex.h"
|
||||
//
|
||||
// Created by WolverinDEV on 03/03/2020.
|
||||
//
|
||||
|
||||
#include "rw_mutex.h"
|
||||
|
||||
1378
src/lock/rw_mutex.h
1378
src/lock/rw_mutex.h
File diff suppressed because it is too large
Load Diff
536
test/rw_lock.cpp
536
test/rw_lock.cpp
@ -1,269 +1,269 @@
|
||||
//
|
||||
// Created by WolverinDEV on 03/03/2020.
|
||||
//
|
||||
|
||||
#include "src/lock/rw_mutex.h"
|
||||
#include <atomic>
|
||||
#include <vector>
|
||||
#include <thread>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
#include <algorithm>
|
||||
|
||||
namespace helper {
|
||||
std::mutex threads_lock{};
|
||||
size_t running_threads{0};
|
||||
std::vector<std::thread> thread_handles{};
|
||||
bool sync_pending{false};
|
||||
|
||||
inline void sync_threads() {
|
||||
static std::condition_variable sync_cv;
|
||||
static size_t synced_threads{0};
|
||||
|
||||
auto timeout = std::chrono::system_clock::now() + std::chrono::seconds{5};
|
||||
std::unique_lock lock{threads_lock};
|
||||
if(++synced_threads == running_threads) {
|
||||
sync_cv.notify_all();
|
||||
synced_threads = 0;
|
||||
sync_pending = false;
|
||||
return;
|
||||
}
|
||||
|
||||
sync_pending = true;
|
||||
if(sync_cv.wait_until(lock, timeout) == std::cv_status::timeout) {
|
||||
std::cerr << "failed to sync threads" << std::endl;
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
template <typename... args_t>
|
||||
inline void create_thread(args_t&&... arguments) {
|
||||
auto callback = std::bind(arguments...);
|
||||
|
||||
std::lock_guard tlock{threads_lock};
|
||||
thread_handles.emplace_back([callback]{
|
||||
callback();
|
||||
|
||||
std::lock_guard tlock{threads_lock};
|
||||
auto it = std::find_if(thread_handles.begin(), thread_handles.end(), [](const auto& thread) {
|
||||
return thread.get_id() == std::this_thread::get_id();
|
||||
});
|
||||
if(it == thread_handles.end())
|
||||
return; /* thread will be joined via await_all_threads */
|
||||
|
||||
if(sync_pending) {
|
||||
std::cerr << "thread terminated while sync was pending" << std::endl;
|
||||
abort();
|
||||
}
|
||||
|
||||
running_threads--;
|
||||
it->detach();
|
||||
thread_handles.erase(it);
|
||||
});
|
||||
running_threads++;
|
||||
}
|
||||
|
||||
inline void await_all_threads() {
|
||||
std::unique_lock thread_lock{threads_lock};
|
||||
while(!thread_handles.empty()) {
|
||||
auto thread = std::move(thread_handles.back());
|
||||
thread_handles.pop_back();
|
||||
thread_lock.unlock();
|
||||
thread.join();
|
||||
thread_lock.lock();
|
||||
|
||||
if(sync_pending) {
|
||||
std::cerr << "thread terminated while sync was pending" << std::endl;
|
||||
abort();
|
||||
}
|
||||
running_threads--;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void testSharedLockLock() {
|
||||
ts::rw_mutex lock{};
|
||||
|
||||
lock.lock_shared();
|
||||
lock.lock_shared();
|
||||
|
||||
lock.unlock_shared();
|
||||
lock.lock_shared();
|
||||
lock.unlock_shared();
|
||||
lock.unlock_shared();
|
||||
}
|
||||
|
||||
void testExclusiveLock() {
|
||||
ts::rw_mutex lock{};
|
||||
|
||||
size_t read_locked{0}, write_locked{0};
|
||||
for(int i = 0; i < 10; i++) {
|
||||
if(rand() % 2 == 0) {
|
||||
write_locked++;
|
||||
lock.lock();
|
||||
lock.unlock();
|
||||
} else {
|
||||
read_locked++;
|
||||
lock.lock_shared();
|
||||
lock.unlock_shared();
|
||||
}
|
||||
}
|
||||
|
||||
/* to ensure that the read and write function has been tested more than once */
|
||||
assert(read_locked > 1);
|
||||
assert(write_locked > 1);
|
||||
}
|
||||
|
||||
void testRW_Multithread() {
|
||||
ts::rw_mutex lock{};
|
||||
|
||||
for(int i = 0; i < 20; i++) {
|
||||
const auto do_sync = i < 5;
|
||||
|
||||
std::atomic<bool> write_locked{false};
|
||||
helper::create_thread([&]{
|
||||
lock.lock();
|
||||
write_locked = true;
|
||||
if(do_sync) helper::sync_threads(); /* sync point 1 */
|
||||
std::this_thread::sleep_for(std::chrono::seconds{1});
|
||||
write_locked = false;
|
||||
lock.unlock();
|
||||
});
|
||||
|
||||
helper::create_thread([&]{
|
||||
if(do_sync) helper::sync_threads(); /* sync point 1 */
|
||||
lock.lock_shared();
|
||||
std::cout << "shared locked" << std::endl;
|
||||
if(write_locked) {
|
||||
std::cerr << "Shared lock succeeded, but thread has been write locked!" << std::endl;
|
||||
return;
|
||||
}
|
||||
std::this_thread::sleep_for(std::chrono::seconds{1});
|
||||
std::cout << "unlocking shared lock" << std::endl;
|
||||
lock.unlock_shared();
|
||||
});
|
||||
helper::await_all_threads();
|
||||
std::cout << "Loop " << i << " passed" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void testLockUpgrade() {
|
||||
std::atomic<bool> lock_released{true};
|
||||
std::atomic<bool> lock_shared{false};
|
||||
ts::rw_mutex lock{};
|
||||
|
||||
lock.lock_shared();
|
||||
std::cout << "[main] Locked shared lock" << std::endl;
|
||||
lock_released = false;
|
||||
lock_shared = true;
|
||||
|
||||
helper::create_thread([&]{
|
||||
std::cout << "Awaiting exclusive lock" << std::endl;
|
||||
lock.lock();
|
||||
std::cout << "Received exclusive lock" << std::endl;
|
||||
if(!lock_released) {
|
||||
std::cerr << "Acquired write lock even thou is hasn't been released!" << std::endl;
|
||||
abort();
|
||||
}
|
||||
|
||||
lock.unlock();
|
||||
});
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds {100});
|
||||
|
||||
if(auto err = lock.upgrade_lock(); err) {
|
||||
std::cerr << "Failed to upgrade lock: " << err << std::endl;
|
||||
abort();
|
||||
}
|
||||
std::cout << "[main] Upgraded shared lock" << std::endl;
|
||||
lock_shared = false;
|
||||
|
||||
helper::create_thread([&]{
|
||||
std::cout << "Awaiting shared lock" << std::endl;
|
||||
lock.lock_shared();
|
||||
std::cout << "Received shared lock" << std::endl;
|
||||
if(!lock_shared) {
|
||||
std::cerr << "Acquired write lock even thou is hasn't been lock in shared mode!" << std::endl;
|
||||
abort();
|
||||
}
|
||||
|
||||
lock.unlock_shared();
|
||||
});
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds {100});
|
||||
lock_shared = true;
|
||||
std::cout << "[main] Downgrading exclusive lock" << std::endl;
|
||||
lock.downgrade_lock();
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds {10});
|
||||
lock_released = true;
|
||||
std::cout << "[main] Releasing shared lock" << std::endl;
|
||||
lock.unlock_shared();
|
||||
|
||||
helper::await_all_threads();
|
||||
}
|
||||
|
||||
void testLockUpgradeRelease() {
|
||||
{
|
||||
ts::rw_mutex lock{};
|
||||
lock.lock_shared();
|
||||
(void) lock.upgrade_lock();
|
||||
lock.unlock();
|
||||
}
|
||||
{
|
||||
ts::rw_mutex lock{};
|
||||
lock.lock_shared();
|
||||
(void) lock.upgrade_lock();
|
||||
lock.downgrade_lock();
|
||||
lock.unlock_shared();
|
||||
}
|
||||
}
|
||||
|
||||
void testLockGuard() {
|
||||
ts::rw_mutex mutex{};
|
||||
ts::rwshared_lock lock{mutex};
|
||||
bool lock_allowed{false};
|
||||
|
||||
if(auto err = lock.auto_lock_exclusive(); err) {
|
||||
std::cerr << "Failed to upgrade lock: " << err << std::endl;
|
||||
abort();
|
||||
}
|
||||
assert(lock.exclusive_locked());
|
||||
|
||||
helper::create_thread([&]{
|
||||
std::cout << "Awaiting exclusive lock" << std::endl;
|
||||
mutex.lock();
|
||||
std::cout << "Received exclusive lock" << std::endl;
|
||||
if(!lock_allowed) {
|
||||
std::cerr << "Acquired write lock even thou is hasn't been released!" << std::endl;
|
||||
abort();
|
||||
}
|
||||
|
||||
mutex.unlock();
|
||||
});
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds {100});
|
||||
|
||||
lock.auto_lock_shared();
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds {100});
|
||||
lock_allowed = true;
|
||||
lock.auto_unlock();
|
||||
helper::await_all_threads();
|
||||
|
||||
lock.lock_exclusive();
|
||||
}
|
||||
|
||||
int main() {
|
||||
{ /* get rid of the unused warnings */
|
||||
ts::rw_unsafe_mutex mutex_a{};
|
||||
ts::rw_safe_mutex mutex_b{};
|
||||
}
|
||||
|
||||
testSharedLockLock();
|
||||
testExclusiveLock();
|
||||
//testRW_Multithread();
|
||||
//TODO: Test lock order
|
||||
testLockUpgrade();
|
||||
testLockUpgradeRelease();
|
||||
testLockGuard();
|
||||
//
|
||||
// Created by WolverinDEV on 03/03/2020.
|
||||
//
|
||||
|
||||
#include "src/lock/rw_mutex.h"
|
||||
#include <atomic>
|
||||
#include <vector>
|
||||
#include <thread>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
#include <algorithm>
|
||||
|
||||
namespace helper {
|
||||
std::mutex threads_lock{};
|
||||
size_t running_threads{0};
|
||||
std::vector<std::thread> thread_handles{};
|
||||
bool sync_pending{false};
|
||||
|
||||
inline void sync_threads() {
|
||||
static std::condition_variable sync_cv;
|
||||
static size_t synced_threads{0};
|
||||
|
||||
auto timeout = std::chrono::system_clock::now() + std::chrono::seconds{5};
|
||||
std::unique_lock lock{threads_lock};
|
||||
if(++synced_threads == running_threads) {
|
||||
sync_cv.notify_all();
|
||||
synced_threads = 0;
|
||||
sync_pending = false;
|
||||
return;
|
||||
}
|
||||
|
||||
sync_pending = true;
|
||||
if(sync_cv.wait_until(lock, timeout) == std::cv_status::timeout) {
|
||||
std::cerr << "failed to sync threads" << std::endl;
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
template <typename... args_t>
|
||||
inline void create_thread(args_t&&... arguments) {
|
||||
auto callback = std::bind(arguments...);
|
||||
|
||||
std::lock_guard tlock{threads_lock};
|
||||
thread_handles.emplace_back([callback]{
|
||||
callback();
|
||||
|
||||
std::lock_guard tlock{threads_lock};
|
||||
auto it = std::find_if(thread_handles.begin(), thread_handles.end(), [](const auto& thread) {
|
||||
return thread.get_id() == std::this_thread::get_id();
|
||||
});
|
||||
if(it == thread_handles.end())
|
||||
return; /* thread will be joined via await_all_threads */
|
||||
|
||||
if(sync_pending) {
|
||||
std::cerr << "thread terminated while sync was pending" << std::endl;
|
||||
abort();
|
||||
}
|
||||
|
||||
running_threads--;
|
||||
it->detach();
|
||||
thread_handles.erase(it);
|
||||
});
|
||||
running_threads++;
|
||||
}
|
||||
|
||||
inline void await_all_threads() {
|
||||
std::unique_lock thread_lock{threads_lock};
|
||||
while(!thread_handles.empty()) {
|
||||
auto thread = std::move(thread_handles.back());
|
||||
thread_handles.pop_back();
|
||||
thread_lock.unlock();
|
||||
thread.join();
|
||||
thread_lock.lock();
|
||||
|
||||
if(sync_pending) {
|
||||
std::cerr << "thread terminated while sync was pending" << std::endl;
|
||||
abort();
|
||||
}
|
||||
running_threads--;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void testSharedLockLock() {
|
||||
ts::rw_mutex lock{};
|
||||
|
||||
lock.lock_shared();
|
||||
lock.lock_shared();
|
||||
|
||||
lock.unlock_shared();
|
||||
lock.lock_shared();
|
||||
lock.unlock_shared();
|
||||
lock.unlock_shared();
|
||||
}
|
||||
|
||||
void testExclusiveLock() {
|
||||
ts::rw_mutex lock{};
|
||||
|
||||
size_t read_locked{0}, write_locked{0};
|
||||
for(int i = 0; i < 10; i++) {
|
||||
if(rand() % 2 == 0) {
|
||||
write_locked++;
|
||||
lock.lock();
|
||||
lock.unlock();
|
||||
} else {
|
||||
read_locked++;
|
||||
lock.lock_shared();
|
||||
lock.unlock_shared();
|
||||
}
|
||||
}
|
||||
|
||||
/* to ensure that the read and write function has been tested more than once */
|
||||
assert(read_locked > 1);
|
||||
assert(write_locked > 1);
|
||||
}
|
||||
|
||||
void testRW_Multithread() {
|
||||
ts::rw_mutex lock{};
|
||||
|
||||
for(int i = 0; i < 20; i++) {
|
||||
const auto do_sync = i < 5;
|
||||
|
||||
std::atomic<bool> write_locked{false};
|
||||
helper::create_thread([&]{
|
||||
lock.lock();
|
||||
write_locked = true;
|
||||
if(do_sync) helper::sync_threads(); /* sync point 1 */
|
||||
std::this_thread::sleep_for(std::chrono::seconds{1});
|
||||
write_locked = false;
|
||||
lock.unlock();
|
||||
});
|
||||
|
||||
helper::create_thread([&]{
|
||||
if(do_sync) helper::sync_threads(); /* sync point 1 */
|
||||
lock.lock_shared();
|
||||
std::cout << "shared locked" << std::endl;
|
||||
if(write_locked) {
|
||||
std::cerr << "Shared lock succeeded, but thread has been write locked!" << std::endl;
|
||||
return;
|
||||
}
|
||||
std::this_thread::sleep_for(std::chrono::seconds{1});
|
||||
std::cout << "unlocking shared lock" << std::endl;
|
||||
lock.unlock_shared();
|
||||
});
|
||||
helper::await_all_threads();
|
||||
std::cout << "Loop " << i << " passed" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void testLockUpgrade() {
|
||||
std::atomic<bool> lock_released{true};
|
||||
std::atomic<bool> lock_shared{false};
|
||||
ts::rw_mutex lock{};
|
||||
|
||||
lock.lock_shared();
|
||||
std::cout << "[main] Locked shared lock" << std::endl;
|
||||
lock_released = false;
|
||||
lock_shared = true;
|
||||
|
||||
helper::create_thread([&]{
|
||||
std::cout << "Awaiting exclusive lock" << std::endl;
|
||||
lock.lock();
|
||||
std::cout << "Received exclusive lock" << std::endl;
|
||||
if(!lock_released) {
|
||||
std::cerr << "Acquired write lock even thou is hasn't been released!" << std::endl;
|
||||
abort();
|
||||
}
|
||||
|
||||
lock.unlock();
|
||||
});
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds {100});
|
||||
|
||||
if(auto err = lock.upgrade_lock(); err) {
|
||||
std::cerr << "Failed to upgrade lock: " << err << std::endl;
|
||||
abort();
|
||||
}
|
||||
std::cout << "[main] Upgraded shared lock" << std::endl;
|
||||
lock_shared = false;
|
||||
|
||||
helper::create_thread([&]{
|
||||
std::cout << "Awaiting shared lock" << std::endl;
|
||||
lock.lock_shared();
|
||||
std::cout << "Received shared lock" << std::endl;
|
||||
if(!lock_shared) {
|
||||
std::cerr << "Acquired write lock even thou is hasn't been lock in shared mode!" << std::endl;
|
||||
abort();
|
||||
}
|
||||
|
||||
lock.unlock_shared();
|
||||
});
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds {100});
|
||||
lock_shared = true;
|
||||
std::cout << "[main] Downgrading exclusive lock" << std::endl;
|
||||
lock.downgrade_lock();
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds {10});
|
||||
lock_released = true;
|
||||
std::cout << "[main] Releasing shared lock" << std::endl;
|
||||
lock.unlock_shared();
|
||||
|
||||
helper::await_all_threads();
|
||||
}
|
||||
|
||||
void testLockUpgradeRelease() {
|
||||
{
|
||||
ts::rw_mutex lock{};
|
||||
lock.lock_shared();
|
||||
(void) lock.upgrade_lock();
|
||||
lock.unlock();
|
||||
}
|
||||
{
|
||||
ts::rw_mutex lock{};
|
||||
lock.lock_shared();
|
||||
(void) lock.upgrade_lock();
|
||||
lock.downgrade_lock();
|
||||
lock.unlock_shared();
|
||||
}
|
||||
}
|
||||
|
||||
void testLockGuard() {
|
||||
ts::rw_mutex mutex{};
|
||||
ts::rwshared_lock lock{mutex};
|
||||
bool lock_allowed{false};
|
||||
|
||||
if(auto err = lock.auto_lock_exclusive(); err) {
|
||||
std::cerr << "Failed to upgrade lock: " << err << std::endl;
|
||||
abort();
|
||||
}
|
||||
assert(lock.exclusive_locked());
|
||||
|
||||
helper::create_thread([&]{
|
||||
std::cout << "Awaiting exclusive lock" << std::endl;
|
||||
mutex.lock();
|
||||
std::cout << "Received exclusive lock" << std::endl;
|
||||
if(!lock_allowed) {
|
||||
std::cerr << "Acquired write lock even thou is hasn't been released!" << std::endl;
|
||||
abort();
|
||||
}
|
||||
|
||||
mutex.unlock();
|
||||
});
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds {100});
|
||||
|
||||
lock.auto_lock_shared();
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds {100});
|
||||
lock_allowed = true;
|
||||
lock.auto_unlock();
|
||||
helper::await_all_threads();
|
||||
|
||||
lock.lock_exclusive();
|
||||
}
|
||||
|
||||
int main() {
|
||||
{ /* get rid of the unused warnings */
|
||||
ts::rw_unsafe_mutex mutex_a{};
|
||||
ts::rw_safe_mutex mutex_b{};
|
||||
}
|
||||
|
||||
testSharedLockLock();
|
||||
testExclusiveLock();
|
||||
//testRW_Multithread();
|
||||
//TODO: Test lock order
|
||||
testLockUpgrade();
|
||||
testLockUpgradeRelease();
|
||||
testLockGuard();
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user