acedia/acedia_atomic.hpp

/*                                                                            *\
**                          Copyright (C) 2009-2010                           **
**       Dominik Charousset < Dominik.Charousset (at) haw-hamburg.de >        **
**                                                                            **
**            MMM       MMMMMM   MMMMMMMMM MMMMMMM   MMM       MMM            **
**           MMMMM     MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM      MMMMM           **
**          MMM MMM   MMM        MMMM      MMM   MMM MMM     MMM MMM          **
**         MMM   MMM  MMM        MMMMMMMMM MMM   MMM MMM    MMM   MMM         **
**        MMMMMMMMMMM MMMM   MMM MMMM      MMM   MMM MMM   MMMMMMMMMMM        **
**       MMM       MMM MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM  MMM       MMM       **
**      MMM         MMM MMMMMM   MMMMMMMMM MMMMMMM   MMM MMM         MMM      **
**                                                                            **
**                                                                            **
** This file is part of the acedia library.                                   **
**                                                                            **
** 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 3 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 acedia. If not, see <http://www.gnu.org/licenses/>.             **
\*                                                                            */

#ifndef ATOMIC_H
#define ATOMIC_H

#include "acedia_config.hpp"
#include <boost/cstdint.hpp>

#if defined(ACEDIA_MACOS)
#  define ACEDIA_MEMORY_BARRIER() OSMemoryBarrier()
#elif defined(ACEDIA_LINUX)
#  define ACEDIA_MEMORY_BARRIER() __sync_synchronize()
#elif defined(ACEDIA_WINDOWS)
#  define ACEDIA_MEMORY_BARRIER() MemoryBarrier()
#endif


namespace acedia
{
    namespace atomic
    {
        template<typename T>
        inline bool compareAndSwap(T * volatile *ptr, T *expectedValue, T *newValue) throw();

        inline bool compareAndSwap(volatile boost::int32_t *ptr, boost::int32_t expectedValue, boost::int32_t newValue) throw();

        inline bool compareAndSwap(volatile boost::uint32_t *ptr, boost::uint32_t expectedValue, boost::uint32_t newValue) throw()
        { return compareAndSwap((boost::int32_t*) ptr, (boost::int32_t) expectedValue, (boost::int32_t) newValue); }

        inline boost::int32_t addAndFetch(volatile boost::int32_t *ptr, boost::int32_t value) throw();

        inline boost::uint32_t addAndFetch(volatile boost::uint32_t *ptr, boost::uint32_t value) throw()
        { return addAndFetch((boost::int32_t*) ptr, (boost::int32_t) value); }

    } // namespace atomic
} // namespace acedia

#if defined(ACEDIA_MACOS)

#include <libkern/OSAtomic.h>

namespace acedia
{
    namespace atomic
    {
        template<typename T>
        inline bool compareAndSwap(volatile T **ptr, T *expectedValue, T *newValue) throw()
        { return OSAtomicCompareAndSwapPtr((void*) expectedValue, (void*) newValue, (void* volatile*) ptr); }

        inline bool compareAndSwap(volatile boost::int32_t *ptr, boost::int32_t expectedValue, boost::int32_t newValue) throw()
        { return OSAtomicCompareAndSwap32(expectedValue, newValue, ptr); }

        inline boost::int32_t addAndFetch(volatile boost::int32_t *ptr, boost::int32_t value) throw()
        { return OSAtomicAdd32(value, ptr); }
    }
}

#elif defined(ACEDIA_LINUX)

namespace acedia
{
    namespace atomic
    {
        template<typename T>
        inline bool compareAndSwap(volatile T **ptr, T *expectedValue, T *newValue) throw()
        { return __sync_bool_compare_and_swap(ptr, expectedValue, newValue); }

        inline bool compareAndSwap(volatile boost::int32_t *ptr, boost::int32_t expectedValue, boost::int32_t newValue) throw()
        { return __sync_bool_compare_and_swap(ptr, expectedValue, newValue); }

        inline boost::int32_t addAndFetch(volatile boost::int32_t *ptr, boost::int32_t value) throw()
        { return __sync_add_and_fetch(ptr, value); }
    }
}

#elif defined(ACEDIA_WINDOWS)

#include <Winsock2.h>
#include <Windows.h>

namespace acedia
{
    namespace atomic
    {
        template<typename T>
        inline bool compareAndSwap(volatile T **ptr, T *expectedValue, T *newValue) throw()
        {
            return expectedValue == InterlockedCompareExchangePointer((PVOID volatile *) ptr, (PVOID) newValue, (PVOID) expectedValue);
        }

        inline bool compareAndSwap(volatile boost::int32_t *ptr, boost::int32_t expectedValue, boost::int32_t newValue) throw()
        { return expectedValue == InterlockedCompareExchange(ptr, newValue, expectedValue); }

        inline boost::int32_t addAndFetch(volatile boost::int32_t *ptr, boost::int32_t value) throw()
        {
            for (;;)
            {
                boost::int32_t v = *ptr;
                if (compareAndSwap(ptr, v, v + value))
                    return v + value;
//              return InterlockedIncrement(ptr, value);
            }
        }
    }
}

#endif

#endif // ATOMIC_H

---