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 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);  }
    const SpinLock &operator=(const SpinLock &) { return *this; }
    const SpinLock &operator=(SpinLock &&) { return *this; }
 
    ~SpinLock() { assert(!get().load());  get().~atomic<bool>();  }
 
    void lock() { while (get().exchange(true)) { } };
 
    void unlock() { get().store(false);  } // Added for standard conformity
 
    bool try_lock() { return !get().exchange(true);  } // Added for standard conformity
 
private:
    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)) { }
}
 
// Wrapper around std::atomic to make it copy-constructable and assignable
template <typename T>
class Atomic : public std::atomic<T> {
public:
    using std::atomic<T>::atomic;
 
    Atomic(const std::atomic<T> &a) : std::atomic<T>(a.load()) { }
    Atomic(const Atomic &a) : std::atomic<T>(a.load()) { }
    Atomic &operator=(const Atomic &a) { std::atomic<T>::store(a.load());  return *this; }
};
 
//namespace std {
//    inline void swap(std::atomic<int> &a1,std::atomic<int> &a2) { 
//        int i = a2.load();
//        a2.store(a1.load());
//        a1.store(i);
//    }
//}
 
// EoF