SYS/SYS_AtomicIntImpl.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        SYS_AtomicIntImpl.h ( SYS Library, C++)
 *
 * COMMENTS:
 */

#ifndef __SYS_AtomicIntImpl__
#define __SYS_AtomicIntImpl__

#include "SYS_API.h"
#include "SYS_Types.h"
#ifdef WIN32
    #if defined(_MSC_VER) && _MSC_VER >= 1400
        #include <intrin.h>
        #define USE_INTRINSICS
    #else
        #include <windows.h>
    #endif
    #define SYS_ATOMIC_INLINE   SYS_FORCE_INLINE
#else
    #define SYS_ATOMIC_INLINE   inline
#endif
#ifdef SOLARIS
#include <bits/atomicity.h> // for __test_and_set
#endif
#ifdef MBSD     
#include <libkern/OSAtomic.h>
#endif

namespace SYS_AtomicIntNS {

#if defined(LINUX) 

// GCC 4.0 doesn't support __sync_lock_test_and_set,
// but GCC 4.1 and onwards do
#if defined(GCC4) && __GNUC_MINOR__ >= 1

SYS_ATOMIC_INLINE static int32
test_and_set(int32 *addr, int val)
{
    return __sync_lock_test_and_set(addr, val);
}

SYS_ATOMIC_INLINE static int32
test_and_add(int32 *addr, int val)
{
    return __sync_fetch_and_add(addr, val);
}

#else

#if !defined(IA64)

SYS_ATOMIC_INLINE static int32
test_and_set(int32 *addr, int32 val)
{
    int32       oldval;
    __asm__ __volatile__("lock xchgl %0, %1"
            : "=r"(oldval), "=m"(*(addr))
            : "0"(val), "m"(*(addr)));
    return oldval;
}

SYS_ATOMIC_INLINE static int32
test_and_add(int32 *addr, int32 val)
{
    int         oldval;
    __asm__ __volatile__("lock xaddl %0, %1"
            : "=r"(oldval), "=m"(*(addr))
            : "0"(val), "m"(*(addr)));
    return oldval;
}

#else

// On IA64 we try the linux instructions...
SYS_ATOMIC_INLINE static int32
test_and_set(int32 *addr, int32 val)
{
    int32       oldval;

    // Note that this ignores the val method and always
    // tries with 1.  This is to match the code snarfed
    // from:
    // http://archives.postgresql.org/pgsql-patches/2000-07/msg00024.php

    __asm__ __volatile__("xchg4 %0=%1, %2"
            : "=r" (oldval), "=m" (*(addr))
            : "r" (1), "1"(*(addr))
            : "memory");

    return oldval;
}

SYS_ATOMIC_INLINE static int32
test_and_add(int32 *addr, int32 val)
{
    int32       oldval = *addr;

    UT_ASSERT(0 && "No test_and_add defined for IA64");
    *addr += val;
    return oldval;
}

#endif  // !defined(IA64)

#endif  // defined(GCC4)

#elif defined(MBSD_INTEL)

SYS_ATOMIC_INLINE static int32
test_and_set(int32 *addr, int32 val)
{
    int32       oldval;
    __asm__ __volatile__("lock xchgl %0, %1"
            : "=r"(oldval), "=m"(*(addr))
            : "0"(val), "m"(*(addr)));
    return oldval;
}

#elif defined(MBSD_PPC)

SYS_ATOMIC_INLINE static int32
test_and_set(int32 *__p, int32 int __newval)
{
      int __res;
       __asm__ __volatile__ (
                "/* Inline test & set */\n"
                "0:\t"
                "lwarx    %0,0,%1 \n\t"
                "cmpwi    %0,0 \n\t"
                "bne-     1f \n\t"
                "stwcx.   %2,0,%1 \n\t"
                "bne-     0b \n"
                "1:\n\t"
                "/* End test & set */"
                : "=&r"(__res)
                : "r"(__p), "r"(__newval)
                : "cr0", "memory");
          return __res;
}

SYS_ATOMIC_INLINE static int32
test_and_add(int32 *__p, int32 int __newval)
{
    int32       oldval = *__p;

    //UT_ASSERT(0 && "No test_and_add defined for MBSD");
    *__p += __newval;
    return oldval;
}

#elif defined(WIN32)

#ifdef USE_INTRINSICS
#pragma intrinsic (_InterlockedExchange)
#pragma intrinsic (_InterlockedExchangeAdd)
#endif

SYS_FORCE_INLINE static int32
test_and_set(int32 *addr, int32 val)
{
#ifdef USE_INTRINSICS
    return (int32)_InterlockedExchange((long *)addr, (long)val);
#else
    return (int32)InterlockedExchange((long *)addr, (long)val);
#endif
}

SYS_FORCE_INLINE static int32
test_and_add(int32 *addr, int32 val)
{
#ifdef USE_INTRINSICS
    return (int32)_InterlockedExchangeAdd((long *)addr, (long)val);
#else
    return (int32)InterlockedExchangeAdd((long *)addr, (long)val);
#endif
}

#elif defined(SOLARIS)

SYS_ATOMIC_INLINE static int32
test_and_set(int32 *addr, int32 val)
{
    int32       oldval = *addr;

    //UT_ASSERT(0 && "No test_and_set defined for SOLARIS");
    *addr = val;
    return oldval;
}

SYS_ATOMIC_INLINE static int32
test_and_add(int32 *addr, int32 val)
{
    int32       oldval = *addr;

    //UT_ASSERT(0 && "No test_and_add defined for SOLARIS");
    *addr += val;
    return oldval;
}

#elif defined (GAMEOS)

SYS_ATOMIC_INLINE static int32
test_and_set(int32 *addr, int32 val)
{
    int32       oldval = *addr;

    *addr = val;
    return oldval;
}

SYS_ATOMIC_INLINE static int32
test_and_add(int32 *addr, int32 val)
{
    int32       oldval = *addr;

    *addr += val;
    return oldval;
}

#else

//UT_ASSERT_COMPILETIME(0);

#endif

}

/// Atomically assigns val to myValue, returning the prior value of
/// myValue.
SYS_ATOMIC_INLINE int32 
SYS_AtomicInt32::exchange(int32 val)
{
    return SYS_AtomicIntNS::test_and_set(&myValue, val);
}

/// Atomically adds val to myValue, returning the prior value of
/// myValue.
SYS_ATOMIC_INLINE int32 
SYS_AtomicInt32::exchangeAdd(int32 val)
{
#ifdef MBSD
    return ::OSAtomicAdd32(val, &myValue) - val;
#else
    return SYS_AtomicIntNS::test_and_add(&myValue, val);
#endif
}

/// Atomically adds val to myValue, returning the new value of myValue.
SYS_ATOMIC_INLINE int32
SYS_AtomicInt32::add(int32 val)
{
#ifdef MBSD
    return ::OSAtomicAdd32(val, &myValue);
#else
    return SYS_AtomicIntNS::test_and_add(&myValue, val) + val;
#endif
}

SYS_ATOMIC_INLINE void
SYS_AtomicInt32::maximum(int32 val)
{
    int peak = exchange(val);
    while (peak > val)
    {
        val = peak;
        peak = exchange(val);
    }
}

#endif

---