iframe-proxy | Sunbelt Computer Software

This repository was archived by the owner on Feb 20, 2021. It is now read-only.
746 lines (686 loc) · 18.3 KB
// Copyright (C) 2012 Vicente J. Botet Escriba
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
#define BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
#define BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
#include <iostream>
#include <boost/thread/mutex.hpp>
#include <boost/thread/shared_mutex.hpp>
#include <boost/thread/lock_algorithms.hpp>
#include <boost/thread/thread_only.hpp>
#include <vector>
#if defined BOOST_THREAD_USES_CHRONO
#include <boost/chrono/chrono_io.hpp>
enum {reading, writing};
int state = reading;
boost::mutex&
    static boost::mutex m;
    return m;
print(const char* tag, unsigned count, char ch)
    boost::lock_guard<boost::mutex> _(cout_mut());
    std::cout << tag << count << ch;
boost::recursive_mutex&
    static boost::recursive_mutex m;
    return m;
void print() {}
template <class A0, class ...Args>
print(const A0& a0, const Args& ...args)
    boost::lock_guard<boost::recursive_mutex> _(cout_mut());
    std::cout << a0;
    print(args...);
template <class A0, class A1, class A2>
print(const A0&, const A1& a1, const A2&)
    assert(a1 > 10000);
namespace S
boost::shared_mutex mut;
void reader()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        mut.lock_shared();
        assert(state == reading);
        ++count;
        mut.unlock_shared();
    print("reader = ", count, '\n');
void writer()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        mut.lock();
        state = writing;
        assert(state == writing);
        state = reading;
        ++count;
        mut.unlock();
    print("writer = ", count, '\n');
void try_reader()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_shared())
            assert(state == reading);
            ++count;
            mut.unlock_shared();
    print("try_reader = ", count, '\n');
void try_writer()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock())
            state = writing;
            assert(state == writing);
            state = reading;
            ++count;
            mut.unlock();
    print("try_writer = ", count, '\n');
void try_for_reader()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_shared_for(boost::chrono::microseconds(5)))
            assert(state == reading);
            ++count;
            mut.unlock_shared();
    print("try_for_reader = ", count, '\n');
void try_for_writer()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_for(boost::chrono::microseconds(5)))
            state = writing;
            assert(state == writing);
            state = reading;
            ++count;
            mut.unlock();
    print("try_for_writer = ", count, '\n');
test_shared_mutex()
  std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        boost::thread t1(reader);
        boost::thread t2(writer);
        boost::thread t3(reader);
        t1.join();
        t2.join();
        t3.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        boost::thread t1(try_reader);
        boost::thread t2(try_writer);
        boost::thread t3(try_reader);
        t1.join();
        t2.join();
        t3.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        boost::thread t1(try_for_reader);
        boost::thread t2(try_for_writer);
        boost::thread t3(try_for_reader);
        t1.join();
        t2.join();
        t3.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
namespace U
boost::upgrade_mutex mut;
void reader()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        mut.lock_shared();
        assert(state == reading);
        ++count;
        mut.unlock_shared();
    print("reader = ", count, '\n');
void writer()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        mut.lock();
        state = writing;
        assert(state == writing);
        state = reading;
        ++count;
        mut.unlock();
    print("writer = ", count, '\n');
void try_reader()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_shared())
            assert(state == reading);
            ++count;
            mut.unlock_shared();
    print("try_reader = ", count, '\n');
void try_writer()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock())
            state = writing;
            assert(state == writing);
            state = reading;
            ++count;
            mut.unlock();
    print("try_writer = ", count, '\n');
void try_for_reader()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_shared_for(boost::chrono::microseconds(5)))
            assert(state == reading);
            ++count;
            mut.unlock_shared();
    print("try_for_reader = ", count, '\n');
void try_for_writer()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_for(boost::chrono::microseconds(5)))
            state = writing;
            assert(state == writing);
            state = reading;
            ++count;
            mut.unlock();
    print("try_for_writer = ", count, '\n');
void upgradable()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        mut.lock_upgrade();
        assert(state == reading);
        ++count;
        mut.unlock_upgrade();
    print("upgradable = ", count, '\n');
void try_upgradable()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_upgrade())
            assert(state == reading);
            ++count;
            mut.unlock_upgrade();
    print("try_upgradable = ", count, '\n');
void try_for_upgradable()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_upgrade_for(boost::chrono::microseconds(5)))
            assert(state == reading);
            ++count;
            mut.unlock_upgrade();
    print("try_for_upgradable = ", count, '\n');
void clockwise()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        mut.lock_shared();
        assert(state == reading);
        if (mut.try_unlock_shared_and_lock())
            state = writing;
        else if (mut.try_unlock_shared_and_lock_upgrade())
            assert(state == reading);
            mut.unlock_upgrade_and_lock();
            state = writing;
        else
            mut.unlock_shared();
            continue;
        assert(state == writing);
        state = reading;
        mut.unlock_and_lock_upgrade();
        assert(state == reading);
        mut.unlock_upgrade_and_lock_shared();
        assert(state == reading);
        mut.unlock_shared();
        ++count;
    print("clockwise = ", count, '\n');
void counter_clockwise()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        mut.lock_upgrade();
        assert(state == reading);
        mut.unlock_upgrade_and_lock();
        assert(state == reading);
        state = writing;
        assert(state == writing);
        state = reading;
        mut.unlock_and_lock_shared();
        assert(state == reading);
        mut.unlock_shared();
        ++count;
    print("counter_clockwise = ", count, '\n');
void try_clockwise()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_shared())
            assert(state == reading);
            if (mut.try_unlock_shared_and_lock())
                state = writing;
            else if (mut.try_unlock_shared_and_lock_upgrade())
                assert(state == reading);
                mut.unlock_upgrade_and_lock();
                state = writing;
            else
                mut.unlock_shared();
                continue;
            assert(state == writing);
            state = reading;
            mut.unlock_and_lock_upgrade();
            assert(state == reading);
            mut.unlock_upgrade_and_lock_shared();
            assert(state == reading);
            mut.unlock_shared();
            ++count;
    print("try_clockwise = ", count, '\n');
void try_for_clockwise()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_shared_for(boost::chrono::microseconds(5)))
            assert(state == reading);
            if (mut.try_unlock_shared_and_lock_for(boost::chrono::microseconds(5)))
                state = writing;
            else if (mut.try_unlock_shared_and_lock_upgrade_for(boost::chrono::microseconds(5)))
                assert(state == reading);
                mut.unlock_upgrade_and_lock();
                state = writing;
            else
                mut.unlock_shared();
                continue;
            assert(state == writing);
            state = reading;
            mut.unlock_and_lock_upgrade();
            assert(state == reading);
            mut.unlock_upgrade_and_lock_shared();
            assert(state == reading);
            mut.unlock_shared();
            ++count;
    print("try_for_clockwise = ", count, '\n');
void try_counter_clockwise()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_upgrade())
            assert(state == reading);
            if (mut.try_unlock_upgrade_and_lock())
                assert(state == reading);
                state = writing;
                assert(state == writing);
                state = reading;
                mut.unlock_and_lock_shared();
                assert(state == reading);
                mut.unlock_shared();
                ++count;
            else
                mut.unlock_upgrade();
    print("try_counter_clockwise = ", count, '\n');
void try_for_counter_clockwise()
    typedef boost::chrono::steady_clock Clock;
    unsigned count = 0;
    Clock::time_point until = Clock::now() + boost::chrono::seconds(3);
    while (Clock::now() < until)
        if (mut.try_lock_upgrade_for(boost::chrono::microseconds(5)))
            assert(state == reading);
            if (mut.try_unlock_upgrade_and_lock_for(boost::chrono::microseconds(5)))
                assert(state == reading);
                state = writing;
                assert(state == writing);
                state = reading;
                mut.unlock_and_lock_shared();
                assert(state == reading);
                mut.unlock_shared();
                ++count;
            else
                mut.unlock_upgrade();
    print("try_for_counter_clockwise = ", count, '\n');
test_upgrade_mutex()
  std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        boost::thread t1(reader);
        boost::thread t2(writer);
        boost::thread t3(reader);
        t1.join();
        t2.join();
        t3.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        boost::thread t1(try_reader);
        boost::thread t2(try_writer);
        boost::thread t3(try_reader);
        t1.join();
        t2.join();
        t3.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        boost::thread t1(try_for_reader);
        boost::thread t2(try_for_writer);
        boost::thread t3(try_for_reader);
        t1.join();
        t2.join();
        t3.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        boost::thread t1(reader);
        boost::thread t2(writer);
        boost::thread t3(upgradable);
        t1.join();
        t2.join();
        t3.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        boost::thread t1(reader);
        boost::thread t2(writer);
        boost::thread t3(try_upgradable);
        t1.join();
        t2.join();
        t3.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        boost::thread t1(reader);
        boost::thread t2(writer);
        boost::thread t3(try_for_upgradable);
        t1.join();
        t2.join();
        t3.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        state = reading;
        boost::thread t1(clockwise);
        boost::thread t2(counter_clockwise);
        boost::thread t3(clockwise);
        boost::thread t4(counter_clockwise);
        t1.join();
        t2.join();
        t3.join();
        t4.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
        state = reading;
        boost::thread t1(try_clockwise);
        boost::thread t2(try_counter_clockwise);
        t1.join();
        t2.join();
    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
//        state = reading;
//        boost::thread t1(try_for_clockwise);
//        boost::thread t2(try_for_counter_clockwise);
//        t1.join();
//        t2.join();
//    std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
namespace Assignment
    typedef boost::upgrade_mutex            mutex_type;
    typedef boost::shared_lock<mutex_type>  SharedLock;
    typedef boost::upgrade_lock<mutex_type> UpgradeLock;
    typedef boost::unique_lock<mutex_type>   Lock;
    mutable mutex_type  mut_;
    std::vector<double> data_;
    A(const A& a)
        SharedLock _(a.mut_);
        data_ = a.data_;
    A& operator=(const A& a)
        if (this != &a)
            Lock       this_lock(mut_, boost::defer_lock);
            SharedLock that_lock(a.mut_, boost::defer_lock);
            boost::lock(this_lock, that_lock);
            data_ = a.data_;
        return *this;
    void swap(A& a)
        Lock this_lock(mut_, boost::defer_lock);
        Lock that_lock(a.mut_, boost::defer_lock);
        boost::lock(this_lock, that_lock);
        data_.swap(a.data_);
    void average(A& a)
        assert(data_.size() == a.data_.size());
        assert(this != &a);
        Lock        this_lock(mut_, boost::defer_lock);
        UpgradeLock share_that_lock(a.mut_, boost::defer_lock);
        boost::lock(this_lock, share_that_lock);
        for (unsigned i = 0; i < data_.size(); ++i)
            data_[i] = (data_[i] + a.data_[i]) / 2;
        SharedLock share_this_lock(boost::move(this_lock));
        Lock that_lock(boost::move(share_that_lock));
        a.data_ = data_;
}  // Assignment
void temp()
    using namespace boost;
    static upgrade_mutex mut;
    unique_lock<upgrade_mutex> ul(mut);
    shared_lock<upgrade_mutex> sl;
    sl = BOOST_THREAD_MAKE_RV_REF(shared_lock<upgrade_mutex>(boost::move(ul)));
  std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
  typedef boost::chrono::high_resolution_clock Clock;
  typedef boost::chrono::duration<double> sec;
  Clock::time_point t0 = Clock::now();
  std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
  S::test_shared_mutex();
  std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
  U::test_upgrade_mutex();
  std::cout << __FILE__ << "[" <<__LINE__ << "]" << std::endl;
  Clock::time_point t1 = Clock::now();
  std::cout << sec(t1 - t0) << '\n';
  return 0;
#error "This platform doesn't support Boost.Chrono"
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

FilesExpand file tree

shared_mutex.cpp

Latest commit

History

shared_mutex.cpp

File metadata and controls
