vertex_mutex.hpp

#pragma once
 
#include <wmtk/threading/spin_mutex.hpp>
 
#include <atomic>
#include <limits>
 
namespace wmtk::threading {
 
class VertexMutex
{
public:
    static constexpr int no_owner() { return std::numeric_limits<int>::max(); }
 
    VertexMutex() = default;
 
    VertexMutex(const VertexMutex&) noexcept {}
    VertexMutex(VertexMutex&&) noexcept {}
    VertexMutex& operator=(const VertexMutex&) noexcept { return *this; }
    VertexMutex& operator=(VertexMutex&&) noexcept { return *this; }
 
    bool trylock() { return m_mutex.try_lock(); }
 
    void unlock()
    {
        // Clear the owner BEFORE releasing the mutex, never after.
        //
        // With the two swapped there is a window in which the vertex is free but still stamped
        // with the departing thread's id. Another thread can acquire it and stamp its own id
        // inside that window, and the departing thread's clear then lands on top -- wiping the
        // *new* owner's stamp. The new owner subsequently reads `no_owner()` for a vertex it
        // actually holds, tries to lock it again, fails (the spin_mutex is not recursive) and
        // aborts an operation that had already succeeded in claiming its whole ring.
        //
        // The window is only a couple of instructions wide, so it does not reproduce by timing
        // in an optimized build; under ThreadSanitizer it showed up as 24 violations in 28k
        // acquisitions. See the `vertex_mutex_owner_integrity` test.
        reset_owner();
        m_mutex.unlock();
    }
 
    int get_owner() const { return m_owner.load(std::memory_order_relaxed); }
 
    void set_owner(int n) { m_owner.store(n, std::memory_order_relaxed); }
 
    void reset_owner() { m_owner.store(no_owner(), std::memory_order_relaxed); }
 
private:
    spin_mutex m_mutex;
    std::atomic<int> m_owner{no_owner()};
};
 
} // namespace wmtk::threading