interlocked.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#include "core/types.h"
#include "core/config.h"
#include <new>
namespace Threading
{
 
using int64 = int64_t;
 
namespace Interlocked
{
using int64 = int64_t;

int Add(int volatile* var, int add);
int64 Add(int64 volatile* var, int64 add);
int Or(int volatile* var, int value);
int64 Or(int64 volatile* var, int64 value);
int And(int volatile* var, int value);
int64 And(int64 volatile* var, int64 value);
int Xor(int volatile* var, int value);
int64 Xor(int64 volatile* var, int64 value);
int Exchange(int volatile* dest, int value);
int64 Exchange(int64 volatile* dest, int64 value);
int CompareExchange(int volatile* dest, int exchange, int comparand);
int64 CompareExchange(int64 volatile* dest, int64 exchange, int64 comparand);
void* ExchangePointer(void* volatile* dest, void* value);
void* CompareExchangePointer(void* volatile* dest, void* exchange, void* comparand);
int Increment(int volatile* var);
int64 Increment(int64 volatile* var);
int Decrement(int volatile* var);
int64 Decrement(int64 volatile* var);
 
struct alignas(std::hardware_destructive_interference_size) AtomicInt
{
    AtomicInt()
        : value(0)
    {}

    AtomicInt(int initial)
        : value(initial)
    {}

    void operator=(int value)
    {
        this->value = value;
    }

    int Add(int add) 
    {
        return Threading::Interlocked::Add((volatile int*)&this->value, add);
    }

    int Sub(int sub)
    {
        return Threading::Interlocked::Add((volatile int*)&this->value, -sub);
    }

    int Or(int mask)
    {
        return Threading::Interlocked::Or((volatile int*)&this->value, mask);
    }

    int And(int mask)
    {
        return Threading::Interlocked::And((volatile int*)&this->value, mask);
    }

    int Exchange(int value)
    {
        return Threading::Interlocked::Exchange((volatile int*)&this->value, value);
    }

    int CompareExchange(int exchange, int comparand)
    {
        return Threading::Interlocked::CompareExchange((volatile int*)&this->value, exchange, comparand);
    }

    int Increment(int incr)
    {
        return Threading::Interlocked::Add((volatile int*)&this->value, incr);
    }

    int Decrement(int decr)
    {
        return Threading::Interlocked::Add((volatile int*)&this->value, -decr);
    }
 
    volatile int value;
};
 
struct alignas(std::hardware_destructive_interference_size) AtomicInt64
{
    AtomicInt64()
        : value(0)
    {}

    AtomicInt64(int64 initial)
        : value(initial)
    {}

    void operator=(int64 value)
    {
        this->value = value;
    }

    int64 Add(int64 add) 
    {
        return Threading::Interlocked::Add((volatile int64*)&this->value, add);
    }

    int64 Sub(int64 sub)
    {
        return Threading::Interlocked::Add((volatile int64*)&this->value, -sub);
    }

    int64 Or(int64 mask)
    {
        return Threading::Interlocked::Or((volatile int64*)&this->value, mask);
    }

    int64 And(int64 mask)
    {
        return Threading::Interlocked::And((volatile int64*)&this->value, mask);
    }

    int64 Exchange(int64 value)
    {
        return Threading::Interlocked::Exchange((volatile int64*)&this->value, value);
    }

    int64 CompareExchange(int64 exchange, int64 comparand)
    {
        return Threading::Interlocked::CompareExchange((volatile int64*)&this->value, exchange, comparand);
    }

    int64 Increment(int64 incr)
    {
        return Threading::Interlocked::Add((volatile int64*)&this->value, incr);
    }

    int64 Decrement(int64 decr)
    {
        return Threading::Interlocked::Add((volatile int64*)&this->value, -decr);
    }
 
    volatile int64 value;
};
 
struct alignas(std::hardware_destructive_interference_size) AtomicPointer
{
    AtomicPointer(void* initial)
        : ptr(initial)
    {}

    void operator=(void* value)
    {
        this->ptr = value;
 
    }

    void* Exchange(void* value)
    {
        return Threading::Interlocked::ExchangePointer((void* volatile*)&this->ptr, value);
    }

    void* CompareExchange(void* exchange, void* comparand)
    {
        return Threading::Interlocked::CompareExchangePointer((void* volatile*)&this->ptr, exchange, comparand);
    }
    volatile void* ptr;
};

struct alignas(std::hardware_destructive_interference_size) AtomicCounter
{
    volatile int counter;
 
    AtomicCounter()
        : counter(0)
    {}

    AtomicCounter(int initial)
        : counter(initial)
    {}

    bool operator==(int value) const
    {
        return this->counter == value;
    }

    bool operator!=(int value) const
    {
        return this->counter != value;
    }

    bool operator>(int value) const
    {
        return this->counter > value;
    }

    bool operator>=(int value) const
    {
        return this->counter >= value;
    }

    bool operator<(int value) const
    {
        return this->counter < value;
    }

    bool operator<=(int value) const
    {
        return this->counter <= value;
    }

    int Increment()
    {
        return Threading::Interlocked::Increment(&this->counter);
    }

    int Decrement()
    {
        return Threading::Interlocked::Decrement(&this->counter);
    }

    int Add(int addend)
    {
        return Threading::Interlocked::Add(&this->counter, addend);
    }

    int Subtract(int subtractor)
    {
        return Threading::Interlocked::Add(&this->counter, -subtractor);
    }

    int Exchange(int value)
    {
        return Threading::Interlocked::Exchange(&this->counter, value);
    }

    void RaceDecrement()
    {
        this->counter--;
    }

    void RaceIncrement()
    {
        this->counter++;
    }

    void RaceExchange(int value)
    {
        this->counter = value;
    }
};

struct alignas(std::hardware_destructive_interference_size) AtomicCounter64
{
    volatile int64 counter;
 
    AtomicCounter64()
        : counter(0)
    {}

    AtomicCounter64(int64 initial)
        : counter(initial)
    {}

    bool operator==(int64 value) const
    {
        return this->counter == value;
    }

    bool operator!=(int64 value) const
    {
        return this->counter != value;
    }

    bool operator>(int64 value) const
    {
        return this->counter > value;
    }

    bool operator>=(int64 value) const
    {
        return this->counter >= value;
    }

    bool operator<(int64 value) const
    {
        return this->counter < value;
    }

    bool operator<=(int64 value) const
    {
        return this->counter <= value;
    }

    int Increment()
    {
        return Threading::Interlocked::Increment(&this->counter);
    }

    int Decrement()
    {
        return Threading::Interlocked::Decrement(&this->counter);
    }

    int64 Add(int64 addend)
    {
        return Threading::Interlocked::Add(&this->counter, addend);
    }

    int64 Subtract(int64 subtractor)
    {
        return Threading::Interlocked::Add(&this->counter, -subtractor);
    }

    int64 Exchange(int64 value)
    {
        return Threading::Interlocked::Exchange(&this->counter, value);
    }

    void RaceDecrement()
    {
        this->counter--;
    }

    void RaceIncrement()
    {
        this->counter++;
    }

    void RaceExchange(int64 value)
    {
        this->counter = value;
    }
};
 
 
} // namespace Interlocked
} // namespace Threading