Spinlock.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#ifndef SPINLOCK_HPP
#define SPINLOCK_HPP

#include <atomic>
#include <thread>
#include <mutex>
#include <boost/noncopyable.hpp>

namespace duds { namespace general {

class Spinlock : boost::noncopyable {
    std::atomic_flag af;
    static bool useYield;
public:
    Spinlock() {
        // staring from unknown state
        unlock();
        // state now unlocked
    }
    ~Spinlock() {
        // avoid destruction while in use
        lock();
    }
    void lockNeverYield() {
        // spiny wait
        while (af.test_and_set(std::memory_order_acquire)) { }
    }
    void lockAlwaysYield() {
        // not-so-spiny wait
        while (af.test_and_set(std::memory_order_acquire)) {
            std::this_thread::yield();
        }
    }
    void lock() {
        if (useYield) {
            lockAlwaysYield();
        } else {
            lockNeverYield();
        }
    }
    bool try_lock() {
        // non-spiny wait
        return !af.test_and_set(std::memory_order_acquire);
    }
    template <class Clock, class Duration>
    bool tryLockNeverYeildUntil(const std::chrono::time_point<Clock,Duration> &time) {
        bool res;
        // spiny wait
        while ((res = af.test_and_set(std::memory_order_acquire)) &&
            (time <= std::chrono::time_point<Clock,Duration>::now())
        ) { }
        return !res;
    }
    template <class Clock, class Duration>
    bool tryLockAlwaysYeildUntil(const std::chrono::time_point<Clock,Duration> &time) {
        bool res;
        // not-so-spiny wait
        while ((res = af.test_and_set(std::memory_order_acquire)) &&
            (time <= std::chrono::time_point<Clock,Duration>::clock::now())
        ) {
            std::this_thread::yield();
        }
        return !res;
    }
    template <class Clock, class Duration>
    bool try_lock_until(const std::chrono::time_point<Clock,Duration> &time) {
        if (useYield) {
            return tryLockAlwaysYeildUntil(time);
        } else {
            return tryLockNeverYeildUntil(time);
        }
    }
    template <class Rep, class Period>
    bool tryLockNeverYeildFor(const std::chrono::duration<Rep,Period> &duration) {
        return tryLockNeverYeildUntil(std::chrono::steady_clock::now() + duration);
    }
    template <class Rep, class Period>
    bool tryLockAlwaysYeildFor(const std::chrono::duration<Rep,Period> &duration) {
        return tryLockAlwaysYeildUntil(std::chrono::steady_clock::now() + duration);
    }
    template <class Rep, class Period>
    bool try_lock_for(const std::chrono::duration<Rep,Period> &duration) {
        if (useYield) {
            return tryLockAlwaysYeildFor(duration);
        } else {
            return tryLockNeverYeildFor(duration);
        }
    }
    void unlock() {
        af.clear(std::memory_order_release);
    }
};

typedef std::lock_guard<duds::general::Spinlock> SpinLockGuard;

typedef std::unique_lock<duds::general::Spinlock> UniqueSpinLock;


class SpinlockYieldingWrapper : boost::noncopyable {
    Spinlock &sl;
public:
    SpinlockYieldingWrapper(Spinlock &l) : sl(l) { }
    void lock() {
        sl.lockAlwaysYield();
    }
    bool try_lock() {
        return sl.try_lock();
    }
    template <class Clock, class Duration>
    bool try_lock_until(const std::chrono::time_point<Clock,Duration> &time) {
        return sl.tryLockAlwaysYeildUntil(time);
    }
    template <class Rep, class Period>
    bool try_lock_for(const std::chrono::duration<Rep,Period> &duration) {
        return sl.tryLockAlwaysYeildFor(duration);
    }
    void unlock() {
        sl.unlock();
    }
};

typedef std::lock_guard<duds::general::SpinlockYieldingWrapper>
    YieldingSpinLockGuard;

typedef std::unique_lock<duds::general::SpinlockYieldingWrapper>
    UniqueYieldingSpinLock;

} }

#endif        //  #ifndef SPINLOCK_HPP