OgreHapticsAtomic.h

Go to the documentation of this file.

/*
This source file is part of OgreHaptics
 (a library for wrapping haptics devices for use with the open-source
 graphics engine OGRE, http://www.ogre3d.org)

Copyright (c) 2006 - 2008 Jorrit de Vries
Also see acknowledgements in Readme.html

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License
as published by the Free Software Foundation; either version 2.1
of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the
Free Software Foundation, Inc.,
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
*/
#ifndef _OgreHapticsAtomic_H__
#define _OgreHapticsAtomic_H__

#include "OgreHapticsPrerequisites.h"

#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
#   define WIN32_LEAN_AND_MEAN
#   include <windows.h>
#   include <intrin.h>
// Define intrinsics
#   pragma intrinsic(_ReadWriteBarrier)
#   pragma intrinsic(_InterlockedIncrement)
#   pragma intrinsic(_InterlockedDecrement)
#   pragma intrinsic(_InterlockedExchange)
#   pragma intrinsic(_InterlockedExchangeAdd)
#   pragma intrinsic(_InterlockedCompareExchange)
#   if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64
#       pragma intrinsic(_InterlockedExchangePointer)
#       pragma intrinsic(_InterlockedCompareExchangePointer)
#   endif
#endif

namespace OgreHaptics {

    // Platform & compiler dependent routines
    // Note: the GCC compiler implementation has not been tested

    inline void memoryReadWriteBarrier(void)
    {
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
        _ReadWriteBarrier();
#elif OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 412
        __sync_synchronize();
#endif
    }

    template<typename T> inline T atomicIncrement(volatile T* ptr)
    {
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
        return (T)_InterlockedIncrement((volatile long*)ptr);
#elif OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 412
        return __sync_fetch_and_add(ptr, 1);
#endif
    }

    template<typename T> inline T atomicDecrement(volatile T* ptr)
    {
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
        return (T)_InterlockedDecrement((volatile long*)ptr);
#elif OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 412
        return __synch_fetch_and_sub(ptr, 1);
#endif
    }

    template<typename T> inline T atomicExchange(volatile T* ptr,
        T value)
    {
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
        return (T)_InterlockedExchange((volatile long*)ptr, (long)value);
#elif OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 412
        // Since __sync_lock_test_and_set is an acquire barrier, we force a
        // full barrier
        __sync_synchronize();
        return __sync_lock_test_and_set(ptr, value);
#endif
    }

    template<typename T> inline T* atomicExchangePtr(T* volatile* ptr,
        T* value)
    {
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
#   if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64
        return (T*)_InterlockedExchangePointer((void* volatile*)ptr, (void*)value);
#   else
        return (T*)_InterlockedExchange((volatile long*)ptr, (long)value);
#   endif
#elif OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 412
        // Since __sync_lock_test_and_set is an acquire barrier, we force a
        // full barrier
        __sync_synchronize();
        return __sync_lock_test_and_set(ptr, value);
#endif
    }

    template<typename T> inline T atomicExchangeAndAdd(volatile T* ptr,
        T value)
    {
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
        return (T)_InterlockedExchangeAdd((volatile long*)ptr, (long)value);
#elif OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 412
        return __sync_fetch_and_add(ptr, value);
#endif
    }

    template<typename T> inline T atomicExchangeAndSubtract(volatile T* ptr,
        T value)
    {
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
        return (T)_InterlockedExchangeAdd((volatile long*)ptr, -((long)value));
#elif OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 412
        return __sync_fetch_and_sub(ptr, value);
#endif
    }

    template<typename T> inline bool atomicCompareAndSwap(volatile T* ptr,
        T oldValue, T newValue)
    {
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
        return _InterlockedCompareExchange((volatile long*)ptr, (long)newValue,
            (long)oldValue) == (long)oldValue;
#elif OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 412
        return __sync_bool_compare_and_swap(ptr, oldValue, newValue);
#endif
    }

    template<typename T> inline bool atomicCompareAndSwapPtr(T* volatile* ptr,
        T* oldValue, T* newValue)
    {
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
#   if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64
        return _InterlockedCompareExchangePointer((void* volatile*)ptr, (void*)newValue,
            (void*)oldValue) == (void*)oldValue;
#   else
        return _InterlockedCompareExchange((volatile long*)ptr, (long)newValue,
            (long)oldValue) == (long)oldValue;
#   endif
#elif OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 412
        return __sync_bool_compare_and_swap(ptr, oldValue, newValue);
#endif
    }

    // Compiler independent routines

    template<typename T> class AtomicScalar
    {
    protected:
        volatile T value;
    public:
        inline AtomicScalar() {}

        inline AtomicScalar(const T& val)
            : value(val)
        {}

        inline AtomicScalar(const AtomicScalar<T>& rhs)
            : value(rhs.get())
        {}

        inline void operator = (const AtomicScalar<T>& rhs)
        {
            atomicExchange(&value, rhs.get());
        }

        inline T operator += (T val)
        {
            return atomicExchangeAndAdd(&value, val) + val;
        }

        inline T operator -= (T val)
        {
            return atomicExchangeAndSubtract(&value, val) - val;
        }

        inline T operator ++ (void)
        {
            return atomicIncrement(&value) - 1;
        }

        inline T operator ++ (int)
        {
            return atomicIncrement(&value);
        }

        inline T operator -- (void)
        {
            return atomicDecrement(&value) + 1;
        }

        inline T operator -- (int)
        {
            return atomicDecrement(&value);
        }

        inline void set(T rhs)
        {
            atomicExchange(&value, rhs);
        }

        inline T get(void) const
        {
            return value;
        }

        inline bool compareAndSwap(T oldValue, T newValue)
        {
            return atomicCompareAndSwap(&value, oldValue, newValue);
        }
    };

}

#endif

---

Last modified Tue Jan 6 22:31:25 2009