spinlock.h

#pragma once
 
#include "basedef.h"
#include <cassert>
#include <atomic>
 
// Spinlock implementation that matches std::mutex interface.
// So you can use std::lock_guard, etc.
//
// I'm aware of all the discussions of why SpinLocks are bad.
// The fact remains that timing tests consistently show
// F3 slows down considerably if you replace this with std::mutex.
// That said - BE CAREFUL because in medium-to-high contention scenarios this does not perform well.
 
// If you define this, then the SpinLock is implemented in terms of a std::mutex
// shoudl be equivalent to std::mutex
//#define USEMUTEX
 
 
#ifdef USEMUTEX
#include <mutex>
class BASE_EXPORT SpinLock : public std::mutex {
public:
 using mutex::mutex;
};
#else
class BASE_EXPORT SpinLock {
public:
 SpinLock() { new(buffer) std::atomic<bool>(false); }
 SpinLock(const SpinLock &) { new(buffer) std::atomic<bool>(false); }
 SpinLock(SpinLock &&) { new(buffer) std::atomic<bool>(false); }
 
 ~SpinLock() { assert(!get().load()); get().~atomic<bool>(); }
 
 inline void lock() { while (get().exchange(true)) { } };
 
 inline void unlock() { get().store(false); } // Added for standard conformity
 
 inline bool try_lock() { return !get().exchange(true); } // Added for standard conformity
 
private:
 void operator=(const SpinLock &) = delete;
 
 std::atomic<bool> &get() { return *reinterpret_cast<std::atomic<bool> *>(buffer); }
 
 char buffer[sizeof(std::atomic<bool>)];
};
#endif
 
// Standard library looking ReverseLock for people using lock_guard, unique_lock, etc.
template <typename T>
class ReverseLock {
public:
 ReverseLock(T &t) : lock_(t) { t.unlock(); }
 ~ReverseLock() { lock_.lock(); }
private:
 T &lock_;
};
 
// Standard library looking ConditionalLock
template <typename T>
class ConditionalLock {
public:
 ConditionalLock(T &t, bool use) : lock_(&t), use_(use) { if (use_) t.lock(); }
 ConditionalLock(T *t, bool use) : lock_(t), use_(use) { if (use_&&t) t->lock(); }
 ~ConditionalLock() { if (use_&&lock_) lock_->unlock(); }
private:
 T *lock_;
 bool use_;
};
 
// Standard library looking ReverseLock for people using lock_guard, unique_lock, etc.
template <typename T>
class ReverseSharedLock {
public:
 ReverseSharedLock(T &t) : lock_(t) { t.unlock_shared(); }
 ~ReverseSharedLock() { lock_.lock_shared(); }
private:
 T &lock_;
};
 
// Update Maximum
template <typename T>
void atomicMax(std::atomic<T> &maxValue, T const &value) noexcept {
 T pvalue = maxValue.load();
 while (pvalue < value and not maxValue.compare_exchange_weak(pvalue, value)) { }
}
 
// Update Minimum
template <typename T>
void atomicMin(std::atomic<T> &minValue, T const &value) noexcept {
 T pvalue = minValue.load();
 while (pvalue > value and not minValue.compare_exchange_weak(pvalue, value)) { }
}
 
// EoF