spinlock.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#include "threading/interlocked.h"
#include "threading/thread.h"
namespace Threading
{
 
class Spinlock
{
public:
    Spinlock();
    ~Spinlock();

    void operator=(Spinlock&& rhs);

    bool Lock();
    void Unlock();
private:
    volatile Threading::ThreadId lock;
};
 
//------------------------------------------------------------------------------
inline 
Spinlock::Spinlock()
    : lock(InvalidThreadId)
{
}
 
//------------------------------------------------------------------------------
inline
Spinlock::~Spinlock()
{
    // Make sure this thread has the lock before we 
    this->Lock();
    this->lock = InvalidThreadId;
}
 
//------------------------------------------------------------------------------
inline void 
Spinlock::operator=(Spinlock&& rhs)
{
    rhs.Lock();
    rhs.lock = InvalidThreadId;
 
    // If this wasn't locked when assigned, early out
    if (InvalidThreadId == this->lock)
        return;
 
    // Lock this thread until whoever is holding it returns the lock
    while (Interlocked::CompareExchange((volatile ThreadIdStorage*)&this->lock, InvalidThreadId, InvalidThreadId) != InvalidThreadId)
    {
        Thread::YieldThread();
    }
}
 
//------------------------------------------------------------------------------
inline bool
Spinlock::Lock()
{
    // Attempt to set the lock, if already 1, yield the thread
    ThreadId threadId = Thread::GetMyThreadId();
 
    // If this thread already owns the spinlock, return early
    if (threadId == this->lock)
        return false;
 
    // Otherwise, enter the spin to exchange the thread id to ours
    while (Interlocked::CompareExchange((volatile ThreadIdStorage*) &this->lock, threadId, InvalidThreadId) != InvalidThreadId)
    {
        Thread::YieldThread();
    }
 
    return true;
}
 
//------------------------------------------------------------------------------
inline void
Spinlock::Unlock()
{
    n_assert(this->lock != InvalidThreadId);
    Threading::Interlocked::Exchange((volatile ThreadIdStorage*) &this->lock, InvalidThreadId);
}
 
struct SpinlockScope
{
    SpinlockScope(Threading::Spinlock* lock)
        : lock(lock)
    {
        this->lock->Lock();
    }
    ~SpinlockScope()
    {
        this->lock->Unlock();
        this->lock = nullptr;
    }
 
    Threading::Spinlock* lock;
};
 
} // namespace Threading