Atomic.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable
// OnixS Software Services Agreement (the Agreement) and Customer end user license
// agreements granting a non-assignable, non-transferable and non-exclusive license
// to use the software for it's own data processing purposes under the terms defined
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or
// reproduction of any part of this source code or associated reference material
// to any other location for further reproduction or redistribution, and any
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in
// accordance with the terms of the Agreement is a violation of copyright law.
//

#pragma once

#if defined(_MSC_VER)
#  include <intrin.h>
#endif

#include <OnixS/CME/MDH/Bootstrap.h>

ONIXS_CMEMDH_NAMESPACE_BEGIN

#if defined(_MSC_VER)

template <size_t SizeOf>
class AtomicOps;

template <>
class AtomicOps<1>
{
    typedef char Integral;

public:
    template <class Atomic, class Target>
    static void read(volatile Atomic* atomic, Target* target)
    {
        *(Integral*) target = *(volatile Integral*) atomic;

        _ReadWriteBarrier();
    }

    template <class Atomic, class Addend>
    static void add(volatile Atomic* atomic, Addend* addend)
    {
        const Integral addendValue = *static_cast<Integral*>(addend);

        *(Integral*) addend = (_InterlockedExchangeAdd8((volatile Integral*) atomic, addendValue) + addendValue);
    }

    template <class Atomic, class Value>
    static void store(volatile Atomic* atomic, const Value* value)
    {
        _InterlockedExchange8((volatile Integral*) atomic, *(const Integral*) value);
    }

    template <class Atomic, class Value>
    static void exchange(volatile Atomic* atomic, Value* value)
    {
        *(Integral*) value = _InterlockedExchange8((volatile Integral*) atomic, *static_cast<Integral*>(value));
    }

    template <class Atomic, class Comparand, class Value>
    static bool compareExchange(volatile Atomic* atomic, Comparand* comparand, const Value* value)
    {
        const Integral comparandValue = *(Integral*) comparand;

        const Integral previous =
            _InterlockedCompareExchange8((volatile Integral*) atomic, *(const Integral*) value, comparandValue);

        if (previous == comparandValue)
        {
            return true;
        }

        *(Integral*) value = previous;

        return false;
    }
};

template <>
class AtomicOps<2>
{
    typedef short Integral;

public:
    template <class Atomic, class Target>
    static void read(volatile Atomic* atomic, Target* target)
    {
        *(Integral*) target = *(volatile Integral*) atomic;

        _ReadWriteBarrier();
    }

    template <class Atomic, class Addend>
    static void add(volatile Atomic* atomic, Addend* addend)
    {
        const Integral addendValue = *static_cast<Integral*>(addend);

        *(Integral*) addend = (_InterlockedExchangeAdd16((volatile Integral*) atomic, addendValue) + addendValue);
    }

    template <class Atomic, class Value>
    static void store(volatile Atomic* atomic, const Value* value)
    {
        _InterlockedExchange16((volatile Integral*) atomic, *(const Integral*) value);
    }

    template <class Atomic, class Value>
    static void exchange(volatile Atomic* atomic, Value* value)
    {
        *(Integral*) value = _InterlockedExchange16((volatile Integral*) atomic, *static_cast<Integral*>(value));
    }

    template <class Atomic, class Comparand, class Value>
    static bool compareExchange(volatile Atomic* atomic, Comparand* comparand, const Value* value)
    {
        const Integral comparandValue = *(Integral*) comparand;

        const Integral previous =
            _InterlockedCompareExchange16((volatile Integral*) atomic, *(const Integral*) value, comparandValue);

        if (previous == comparandValue)
        {
            return true;
        }

        *(Integral*) value = previous;

        return false;
    }
};

template <>
class AtomicOps<4>
{
    typedef long Integral;

public:
    template <class Atomic, class Target>
    static void read(volatile Atomic* atomic, Target* target)
    {
        *(Integral*) target = *(volatile Integral*) atomic;

        _ReadWriteBarrier();
    }

    template <class Atomic, class Addend>
    static void add(volatile Atomic* atomic, Addend* addend)
    {
        const Integral addendValue = *static_cast<Integral*>(addend);

        *(Integral*) addend = (_InterlockedExchangeAdd((volatile Integral*) atomic, addendValue) + addendValue);
    }

    template <class Atomic, class Value>
    static void store(volatile Atomic* atomic, const Value* value)
    {
        _InterlockedExchange((volatile Integral*) atomic, *(const Integral*) value);
    }

    template <class Atomic, class Value>
    static void exchange(volatile Atomic* atomic, Value* value)
    {
        *(Integral*) value = _InterlockedExchange((volatile Integral*) atomic, *static_cast<Integral*>(value));
    }

    template <class Atomic, class Comparand, class Value>
    static bool compareExchange(volatile Atomic* atomic, Comparand* comparand, const Value* value)
    {
        const Integral comparandValue = *(Integral*) comparand;

        const Integral previous =
            _InterlockedCompareExchange((volatile Integral*) atomic, *(const Integral*) value, comparandValue);

        if (previous == comparandValue)
        {
            return true;
        }

        *(Integral*) value = previous;

        return false;
    }
};

template <>
class AtomicOps<8>
{
    typedef long long Integral;

public:
    template <class Atomic, class Target>
    static void read(volatile Atomic* atomic, Target* target)
    {
        *(Integral*) target = *(volatile Integral*) atomic;

        _ReadWriteBarrier();
    }

    template <class Atomic, class Addend>
    static void add(volatile Atomic* atomic, Addend* addend)
    {
        const Integral addendValue = *static_cast<Integral*>(addend);

        *(Integral*) addend = (_InterlockedExchangeAdd64((volatile Integral*) atomic, addendValue) + addendValue);
    }

    template <class Atomic, class Value>
    static void store(volatile Atomic* atomic, const Value* value)
    {
        _InterlockedExchange64((volatile Integral*) atomic, *(const Integral*) value);
    }

    template <class Atomic, class Value>
    static void exchange(volatile Atomic* atomic, Value* value)
    {
        *(Integral*) value = _InterlockedExchange64((volatile Integral*) atomic, *static_cast<Integral*>(value));
    }

    template <class Atomic, class Comparand, class Value>
    static bool compareExchange(volatile Atomic* atomic, Comparand* comparand, const Value* value)
    {
        const Integral comparandValue = *(Integral*) comparand;

        const Integral previous =
            _InterlockedCompareExchange64((volatile Integral*) atomic, *(const Integral*) value, comparandValue);

        if (previous == comparandValue)
        {
            return true;
        }

        *(Integral*) value = previous;

        return false;
    }
};

//

template <typename Type>
struct Atomic
{
    static Type read(volatile Type& atomic)
    {
        Type value = Type();

        AtomicOps<sizeof(Type)>::read(&atomic, &value);

        return value;
    }

    static void store(volatile Type& atomic, Type value)
    {
        AtomicOps<sizeof(Type)>::store(&atomic, &value);
    }

    static void exchange(volatile Type& atomic, Type& value)
    {
        AtomicOps<sizeof(Type)>::exchange(&atomic, &value);
    }

    static bool compareStore(volatile Type& atomic, Type comparand, Type value)
    {
        return AtomicOps<sizeof(Type)>::compareExchange(&atomic, &comparand, &value);
    }

    static bool compareExchange(volatile Type& atomic, Type comparand, Type& value)
    {
        return AtomicOps<sizeof(Type)>::compareExchange(&atomic, &comparand, &value);
    }
};

#elif defined(__GNUC__)

template <typename Type>
struct Atomic
{
    static Type read(volatile Type& atomic)
    {
        const Type value = atomic;

        __sync_synchronize();

        return value;
    }

    static void store(volatile Type& atomic, Type value)
    {
        (void) (__sync_lock_test_and_set(&atomic, value));
    }

    static void exchange(volatile Type& atomic, Type& value)
    {
        value = __sync_lock_test_and_set(&atomic, value);
    }

    static bool compareStore(volatile Type& atomic, Type comparand, Type value)
    {
        return __sync_bool_compare_and_swap(&atomic, comparand, value);
    }

    static bool compareExchange(volatile Type& atomic, Type comparand, Type& value)
    {
        const Type oldValue = __sync_val_compare_and_swap(&atomic, comparand, value);

        if (oldValue == comparand)
            return true;

        value = oldValue;

        return false;
    }
};

#endif // Toolset selector.

template <typename Type, Type Value>
class AtomicScopedStore
{
public:
    AtomicScopedStore(volatile Type& variable)
        : variable_(variable)
    {
    }

    ~AtomicScopedStore()
    {
        Atomic<Type>::store(variable_, Value);
    }

private:
    volatile Type& variable_;

    AtomicScopedStore(const AtomicScopedStore&);

    AtomicScopedStore& operator=(const AtomicScopedStore&);
};

ONIXS_CMEMDH_NAMESPACE_END