EQ2EMu/EQ2/source/depends/boost_1_72_0/libs/thread/example/shared_mutex.cpp

// 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;

#if 1

boost::mutex&
cout_mut()
{
    static boost::mutex m;
    return m;
}

void
print(const char* tag, unsigned count, char ch)
{
    boost::lock_guard<boost::mutex> _(cout_mut());
    std::cout << tag << count << ch;
}

#elif 0

boost::recursive_mutex&
cout_mut()
{
    static boost::recursive_mutex m;
    return m;
}

void print() {}

template <class A0, class ...Args>
void
print(const A0& a0, const Args& ...args)
{
    boost::lock_guard<boost::recursive_mutex> _(cout_mut());
    std::cout << a0;
    print(args...);
}

#else

template <class A0, class A1, class A2>
void
print(const A0&, const A1& a1, const A2&)
{
    assert(a1 > 10000);
}

#endif

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');
}

void
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');
}

void
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
{

class A
{
    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_;

public:

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

int main()
{
  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;
}

#else
#error "This platform doesn't support Boost.Chrono"
#endif