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