TeaSpeakLibrary/test/rw_lock.cpp

//
// 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();
}