rwlock.hh

/*
* This file is open source software, licensed to you under the terms
* of the Apache License, Version 2.0 (the "License"). See the NOTICE file
* distributed with this work for additional information regarding copyright
* ownership. You may not use this file except in compliance with the License.
*
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
/*
 * Copyright (C) 2015 Cloudius Systems, Ltd.
 */
 
#pragma once
 
#include <seastar/core/semaphore.hh>
 
namespace seastar {
 
// lock / unlock semantics for rwlock, so it can be used with with_lock()
template<typename Clock>
class basic_rwlock;
 
template<typename Clock = typename timer<>::clock>
class rwlock_for_read {
public:
    future<> lock() {
        return static_cast<basic_rwlock<Clock>*>(this)->read_lock();
    }
    void unlock() {
        static_cast<basic_rwlock<Clock>*>(this)->read_unlock();
    }
    friend class basic_rwlock<Clock>;
};
 
template<typename Clock = typename timer<>::clock>
class rwlock_for_write {
public:
    future<> lock() {
        return static_cast<basic_rwlock<Clock>*>(this)->write_lock();
    }
    void unlock() {
        static_cast<basic_rwlock<Clock>*>(this)->write_unlock();
    }
    friend class basic_rwlock<Clock>;
};
 
 
 
template<typename Clock = typename timer<>::clock>
class basic_rwlock : private rwlock_for_read<Clock>, rwlock_for_write<Clock> {
    using semaphore_type = basic_semaphore<semaphore_default_exception_factory, Clock>;
 
    static constexpr size_t max_ops = semaphore_type::max_counter();
 
    semaphore_type _sem;
public:
    basic_rwlock()
            : _sem(max_ops) {
    }
 
    rwlock_for_read<Clock>& for_read() {
        return *this;
    }
 
    rwlock_for_write<Clock>& for_write() {
        return *this;
    }
 
    future<> read_lock(typename semaphore_type::time_point timeout = semaphore_type::time_point::max()) {
        return _sem.wait(timeout);
    }
 
    future<> read_lock(abort_source& as) {
        return _sem.wait(as);
    }
 
    void read_unlock() {
        assert(_sem.current() < max_ops);
        _sem.signal();
    }
 
    future<> write_lock(typename semaphore_type::time_point timeout = semaphore_type::time_point::max()) {
        return _sem.wait(timeout, max_ops);
    }
 
    future<> write_lock(abort_source& as) {
        return _sem.wait(as, max_ops);
    }
 
    void write_unlock() {
        assert(_sem.current() == 0);
        _sem.signal(max_ops);
    }
 
    bool try_read_lock() {
        return _sem.try_wait();
    }
 
    bool try_write_lock() {
        return _sem.try_wait(max_ops);
    }
 
    using holder = semaphore_units<semaphore_default_exception_factory, Clock>;
 
    future<holder> hold_read_lock(typename semaphore_type::time_point timeout = semaphore_type::time_point::max()) {
        return get_units(_sem, 1, timeout);
    }
 
    future<holder> hold_read_lock(abort_source& as) {
        return get_units(_sem, 1, as);
    }
 
    future<holder> hold_write_lock(typename semaphore_type::time_point timeout = semaphore_type::time_point::max()) {
        return get_units(_sem, max_ops, timeout);
    }
 
    future<holder> hold_write_lock(abort_source& as) {
        return get_units(_sem, max_ops, as);
    }
 
    bool locked() const {
        return _sem.available_units() != max_ops;
    }
 
    friend class rwlock_for_read<Clock>;
    friend class rwlock_for_write<Clock>;
};
 
using rwlock = basic_rwlock<>;
 
 
}