Boost Shared_lock / Unique_lock，给作者优先权？

Question

I have a multithreaded application that i am writing using Boost Thread locking.

In this case, there is one writer, and multiple readers. As I have it now, the writer seems to wait for all the readers to complete before it can write again.

What i want, is to give the writer priority, so that if it wants to write again, it does so, no matter what. the readers work around it. For example:

Now:

Writer;
reader1;
reader2;
reader3;
reader4;

What i would like, is:

Writer;
reader1;
reader2;
Writer(if ready);
reader3;
reader4;

Is this possible? My code is replicated below:

typedef boost::shared_mutex Lock;
typedef boost::unique_lock< Lock > WriteLock;
typedef boost::shared_lock< Lock > ReadLock;
Lock frameLock;

cv::Mat currentFrame;
bool frameOk;

void writer()
{
    while (true)
    {
        cv::Mat frame;
        cv::Mat src = cv::imread("C:\\grace_17.0001.jpg");
        cv::resize(src, frame, cv::Size(src.cols / 4, src.rows / 4));

        int64 t0 = cv::getTickCount();


        WriteLock w_lock(frameLock);
        frame.copyTo(currentFrame);
        frameLock.unlock();

        frameOk = true; // tells read we have at least one frame

        int64 t1 = cv::getTickCount();
        double secs = (t1 - t0) / cv::getTickFrequency();
        std::cout << "wait time WRITE: " << secs * 1000 << std::endl;
    }
}

void readerTwo(int wait)
{
    while (true)
    {
        if (frameOk) // if first frame is written
        {
            static cv::Mat readframe;

            int64 t0 = cv::getTickCount();


            //gets frame
            ReadLock r_lockz(frameLock);
            currentFrame.copyTo(readframe);
            r_lockz.unlock();

            std::cout << "READ: " << std::to_string(wait)<< std::endl;

            cv::imshow(std::to_string(wait), readframe);
            cv::waitKey(1);
            std::this_thread::sleep_for(std::chrono::milliseconds(20));
        }
    }
}



void main()
{
    const int readerthreadcount = 50;

    std::vector<boost::thread*> readerthread;

    boost::thread* wThread = new boost::thread(writer);


    for (int i = 0; i<readerthreadcount; i++) {
        ostringstream id;  id << "reader" << i + 1;
        readerthread.push_back(new boost::thread(readerTwo, (i)));
    }

    wThread->join(); delete wThread;

    for (int i = 0; i<readerthreadcount; i++) {
        readerthread[i]->join(); delete readerthread[i];
    }

}

Thank you.

Answer 1

Writer starvation is a typical problem with reader/writer locks.

Reader/writer locks unfortunately have to be tuned per-algorithm and per-architecture. (At least until something smarter is developed.)

Is this possible?

Yes, it's possible. With condition variables. Have a count waitingWriters. When a writer comes in, it acquires the mutex, increments waitingWriters, then waits on condition readerCount == 0. When a reader thread ends, it acquires the mutex, decrements readerCount, and signals the writer condition if readerCount == 0. When a reader thread comes in, it acquires the mutex. If waitingWriters == 0, increment readerCount and release the mutex. Otherwise wait on condition waitingWriters == 0. When a writer thread finishes, it acquires the mutex. If waitingWriters == 0, it signals the reader condition. Otherwise, it signals the next writer.

Note that this algorithm I just gave you:

1. Now prioritizes writes over reads. It is the other extreme in that reads can be starved instead of writes.
2. Only uses 1 mutex. (not a reader mutex & writer mutex)
3. Wouldn't be suitable for quick reads ie reads whose read operation is shorter than one scheduling timeslice. For that you would want to use spinlocks (check out the Big Reader)

The tuning depends on many factors, the most important of which are the ratio of reader vs writer threads and how long the critical sections are.

Answer 2

Here is my higly efficient write-prioritized shared mutex. In optimal cases, it needs only one atomic exchange for locking and unlocking - in contrast to other implementations which need two atomic exchanges.

#pragma once
#include <cstdint>
#include <cassert>
#include <thread>
#include <new>
#include <atomic>
#include "semaphore.h"

static_assert(std::atomic<std::uint64_t>::is_always_lock_free, "std::uint64_t must be lock-free");

class alignas(std::hardware_constructive_interference_size) wprio_shared_mutex
{
public:
         wprio_shared_mutex();
         wprio_shared_mutex( wprio_shared_mutex const & ) = delete;
         ~wprio_shared_mutex();
    void lock_shared();
    void unlock_shared();
    void shared_to_write();
    void lock_writer();
    void write_to_shared();
    void unlock_writer();
    bool we_are_writer();

private:
    std::atomic<std::uint64_t> m_atomic; // bit  0 - 20: readers
                                         // bit 21 - 41: waiting readers
                                         // bit 42 - 62: waiting writers
                                         // bit      61: writer-flag
    std::thread::id            m_writerId;
    std::uint32_t              m_writerRecursionCount;
    semaphore                  m_releaseReadersSem,
                               m_releaseWriterSem;

    static unsigned const      WAITING_READERS_BASE   = 21,
                               WAITING_WRITERS_BASE   = 42,
                               WRITER_FLAG_BASE       = 63;
    static std::uint64_t const MASK21                 = 0x1FFFFFu;
    static std::uint64_t const READERS_MASK           = MASK21,
                               WAITING_READERS_MASK   = MASK21           << WAITING_READERS_BASE,
                               WAITING_WRITERS_MASK   = MASK21           << WAITING_WRITERS_BASE,
                               WRITER_FLAG_MASK       = (std::uint64_t)1 << WRITER_FLAG_BASE;
    static std::uint64_t const READER_VALUE           = (std::uint64_t)1,
                               WAITING_READERS_VALUE  = (std::uint64_t)1 << WAITING_READERS_BASE,
                               WAITING_WRITERS_VALUE  = (std::uint64_t)1 << WAITING_WRITERS_BASE;

    static bool check( std::uint64_t flags );
};

inline
bool wprio_shared_mutex::check( std::uint64_t flags )
{
    unsigned readers        = (unsigned)(flags                           & MASK21),
             waitingReaders = (unsigned)((flags >> WAITING_READERS_BASE) & MASK21),
             waitingWriters = (unsigned)((flags >> WAITING_WRITERS_BASE) & MASK21),
             writerFlag     = (unsigned)((flags >> WRITER_FLAG_BASE)     & 1);
    if( readers && (waitingReaders || writerFlag) )
        return false;
    if( waitingReaders && (readers || !writerFlag) )
        return false;
    if( waitingWriters && !(writerFlag || readers) )
        return false;
    if( writerFlag && readers )
        return false;
    return true;
}

wprio_shared_mutex::wprio_shared_mutex()
{
    m_atomic.store( 0, std::memory_order_relaxed );
}

wprio_shared_mutex::~wprio_shared_mutex()
{
    assert(m_atomic == 0);
}

void wprio_shared_mutex::lock_shared()
{
    using namespace std;
    for( uint64_t cmp = m_atomic.load( std::memory_order_relaxed ); ; )
    {
        assert(check( cmp ));
        if( (cmp & WRITER_FLAG_MASK) == 0 )
        [[likely]]
        {
            if( m_atomic.compare_exchange_weak( cmp, cmp + READER_VALUE, memory_order_acquire, memory_order_relaxed ) )
                [[likely]]
                return;
        }
        else
            if( m_atomic.compare_exchange_weak( cmp, cmp + WAITING_READERS_VALUE, memory_order_relaxed, memory_order_relaxed ) )
            [[likely]]
            {
                m_releaseReadersSem.forced_wait();
                return;
            }
    }
}

void wprio_shared_mutex::unlock_shared()
{
    using namespace std;
    for( uint64_t cmp = m_atomic.load( std::memory_order_relaxed ); ; )
    {
        assert(check( cmp ));
        assert((cmp & READERS_MASK) >= READER_VALUE);
        if( (cmp & READERS_MASK) != READER_VALUE || (cmp & WAITING_WRITERS_MASK) == 0 )
        [[likely]]
        {
            if( m_atomic.compare_exchange_weak( cmp, cmp - READER_VALUE, memory_order_relaxed, memory_order_relaxed ) )
                [[likely]]
                return;
        }
        else
        {
            assert(!(cmp & WRITER_FLAG_MASK));
            if( m_atomic.compare_exchange_weak( cmp, (cmp - READER_VALUE - WAITING_WRITERS_VALUE) | WRITER_FLAG_MASK, memory_order_relaxed, memory_order_relaxed ) )
            [[likely]]
            {
                m_releaseWriterSem.forced_release( 1 );
                return;
            }
        }
    }
}

void wprio_shared_mutex::shared_to_write()
{
    using namespace std;
    for( uint64_t cmp = m_atomic.load( std::memory_order_relaxed ); ; )
    {
        assert(check( cmp ));
        assert((cmp & READERS_MASK) >= READER_VALUE);
        if( (cmp & READERS_MASK) == READER_VALUE )
        [[likely]]
        {
            assert(!(cmp & WRITER_FLAG_MASK));
            if( m_atomic.compare_exchange_weak( cmp, (cmp - READER_VALUE) | WRITER_FLAG_MASK, memory_order_acquire, memory_order_relaxed ) )
            [[likely]]
            {
                m_writerId             = this_thread::get_id();
                m_writerRecursionCount = 0;
                return;
            }
        }
        else
        {
            assert((cmp & READERS_MASK) > READER_VALUE);
            if( m_atomic.compare_exchange_weak( cmp, cmp - READER_VALUE + WAITING_WRITERS_VALUE, memory_order_relaxed, memory_order_relaxed ) )
            [[likely]]
            {
                m_releaseWriterSem.forced_wait();
                m_writerId             = this_thread::get_id();
                m_writerRecursionCount = 0;
                return;
            }
        }
    }
}

void wprio_shared_mutex::lock_writer()
{
    using namespace std;
    uint64_t cmp = m_atomic.load( std::memory_order_acquire );
    if( (cmp & WRITER_FLAG_MASK) && m_writerId == this_thread::get_id() )
    {
        ++m_writerRecursionCount;
        return;
    }
    for( ; ; )
    {
        assert(check( cmp ));
        if( (cmp & (WRITER_FLAG_MASK | READERS_MASK)) == 0 )
        [[likely]
        {
            if( m_atomic.compare_exchange_weak( cmp, cmp | WRITER_FLAG_MASK, memory_order_acquire, memory_order_relaxed ) )
            [[likely]
            {
                m_writerId             = this_thread::get_id();
                m_writerRecursionCount = 0;
                return;
            }
        }
        else
            if( m_atomic.compare_exchange_weak( cmp, cmp + WAITING_WRITERS_VALUE, memory_order_relaxed, memory_order_relaxed ) )
            [[likely]]
            {
                m_releaseWriterSem.forced_wait();
                m_writerId             = this_thread::get_id();
                m_writerRecursionCount = 0;
                return;
            }
    }
}

void wprio_shared_mutex::unlock_writer()
{
    using namespace std;
    uint64_t cmp = m_atomic.load( std::memory_order_relaxed );
    if( (cmp & WRITER_FLAG_MASK) && m_writerRecursionCount && m_writerId == this_thread::get_id() )
    {
        --m_writerRecursionCount;
        return;
    }
    m_writerId = thread::id();
    for( ; ; )
    {
        assert(cmp & WRITER_FLAG_MASK && !(cmp & READERS_MASK));
        assert(check( cmp ));
        if( (cmp & WAITING_WRITERS_MASK) != 0 )
            [[unlikely]]
            if( m_atomic.compare_exchange_weak( cmp, cmp - WAITING_WRITERS_VALUE, memory_order_release, memory_order_relaxed ) )
            [[likely]]
            {
                m_releaseWriterSem.forced_release( 1 );
                return;
            }
            else
                continue;
        if( (cmp & WAITING_READERS_MASK) != 0 )
        [[unlikely]]
        {
            uint64_t wakeups = (cmp & WAITING_READERS_MASK) >> WAITING_READERS_BASE;
            if( m_atomic.compare_exchange_weak( cmp, (cmp & ~WRITER_FLAG_MASK) - (cmp & WAITING_READERS_MASK) + wakeups, memory_order_release, memory_order_relaxed ) )
            [[likely]]
            {
                m_releaseReadersSem.forced_release( (unsigned)wakeups );
                return;
            }
            else
                continue;
        }
        if( m_atomic.compare_exchange_weak( cmp, 0, memory_order_release, memory_order_relaxed ) )
            [[likely]]
            return;
    }
}

bool wprio_shared_mutex::we_are_writer()
{
    return (m_atomic.load( std::memory_order_relaxed ) & WRITER_FLAG_MASK) && m_writerId == std::this_thread::get_id();
}

The algorithm allows continuing readers, but as soon as a writer registers for writing, further readers are enqueued and the current readers are waited to be finished; and this is all done though a single 64 bit atomic value!

The code allows reader- as well as writer-recursion. But when you are reader multiple times, you shouldn't do shared_to_write(); you'll get a deadlock then. The ability to have recursion comes by nature for shared reading and has no extra-overhead. But for writing there's an additional recursion-counter as well as a thread::id.

I'm not going to include my semaphore-class here as it should self-explanatory. With my semaphore-class I have forced_wait and forced_release; this are two functions which repeatedly do a wait or release if it fails.

The [[likely]]- and [[unlikely]]-tags are C++20 optimization-hints. You can remove them with earlier compilers. The we_are_writer-method checks if the current thread has write-ownership. This could be used fe for debugging-purposes with assert().

The shared-mutex is aligned to cachelines through the alignas()-directive. But the whole object itself may be larger than a cacheline because of the two semaphores at the end of the object. But the data for the short locking-path is at the header which fits into a cacheline. It shouldn't hurt if the semaphores at the end of the object don't fit into the same cacheline since sleepy locking is slow anyay.

The object isn't neither copyable, nor moveable because the semaphore might not be also. This might be fe because POSIX-semaphores rely on a non-copyable sem_t-datatype which might me directly embedded in a C++ semaphore-datatype and thereby make it non-copy or -moveable.