spinLock.hpp

Go to the documentation of this file.

/**
 * @defgroup ion_locks Locks
 * Provides ion::SpinLock.
 *
 * @ingroup ion
 *
 * @file
 * @ingroup ion_locks
 *
 * @brief ion::SpinLock
 *
 * @copyright
 *   SPDX-FileCopyrightText: 2022-2024 European Southern Observatory (ESO)
 
 *   SPDX-License-Identifier: LGPL-3.0-only
 */
#ifndef ION_SPINLOCK_HPP
#define ION_SPINLOCK_HPP
#include <atomic>
 
#include <ion/detail/macros.hpp>
 
namespace ion {
 
/**
 * Busy spinning lock that satisfies
 * [*BasicLockable*](https://en.cppreference.com/w/cpp/named_req/BasicLockable),
 * [*Lockable*](https://en.cppreference.com/w/cpp/named_req/Lockable) and
 * [*Mutex*](https://en.cppreference.com/w/cpp/named_req/Mutex) requirements.
 *
 * Implementation busy-spins without sleeping or yielding, does not detect resource
 * deadlocks and does not throw any exceptions.
 *
 * @note This is not suitable for most general programs.
 *
 * Can be used with e.g. [`std::lock_guard`](https://en.cppreference.com/w/cpp/thread/lock_guard),
 * [`std::scoped_lock`](https://en.cppreference.com/w/cpp/thread/scoped_lock) and
 * [`std::unique_lock`](https://en.cppreference.com/w/cpp/thread/unique_lock).
 *
 * @memory_order{
 *   See [*Mutex*](https://en.cppreference.com/w/cpp/named_req/Mutex).
 * }
 * @thread_safe
 * @ingroup ion_locks
 * @headerfile <> <ion/spinLock.hpp>
 */
class SpinLock {
public:
    SpinLock() noexcept = default;
    SpinLock(SpinLock const&) = delete;
 
    /**
     * Acquires the lock.
     *
     * @pre lock must not be held.
     * @post lock is held.
     */
    inline void lock() noexcept;  // NOLINT(readability-identifier-naming)
 
    /**
     * Attempts to acquire the lock.
     *
     * @pre lock must not be held.
     *
     * @returns true if lock was acquired.
     * @returns false otherwise.
     */
    ION_FORCE_INLINE inline bool try_lock() noexcept;  // NOLINT(readability-identifier-naming)
 
    /**
     * Releases held lock.
     *
     * @pre lock must be held.
     */
    inline void unlock() noexcept;  // NOLINT(readability-identifier-naming)
 
private:
    static_assert(std::atomic_bool::is_always_lock_free);
 
    /// true if locked.
    std::atomic_bool m_lock = false;
};
 
void SpinLock::lock() noexcept {  // NOLINT(readability-identifier-naming)
    while (!try_lock()) {
        ION_PAUSE();
    }
}
 
bool SpinLock::try_lock() noexcept {  // NOLINT(readability-identifier-naming)
    return m_lock.load(std::memory_order_relaxed) == false &&
           m_lock.exchange(true, std::memory_order_acquire) == false;
}
 
void SpinLock::unlock() noexcept {  // NOLINT(readability-identifier-naming)
    m_lock.store(false, std::memory_order_release);
}
 
}  // namespace ion
#endif  // ION_SPINLOCK_HPP