Locks.h

//Thread Locking constructs
//Luke Lenhart, 2007
//See /docs/License.txt for details on how this code may be used.

#pragma once

namespace MPMA
{
    //Atomically increments an integer
    inline void AtomicIntInc(volatile uint *pint)
    {
        asm( "lock incl (%0);"
            :
            :"r"(pint)
            :"%0", "memory");
    }

    //Atomically decrements an integer
    inline void AtomicIntDec(volatile uint *pint)
    {
        asm( "lock decl (%0);"
            :
            :"r"(pint)
            :"%0", "memory");
    }
    
    //Atomically adds one integer to another and returns the value of the original
    inline int AtomicIntAdd(volatile int *pint, int addValue)
    {
        int rval;
        asm volatile( "lock xaddl %2, (%1);"
                      "movl %2, %0"
                     :"=g"(rval)
                     :"r"(pint), "r"(addValue)
                     :"%0", "%1", "%2", "memory");
        return rval;
    }

    //Compares expectedValue with the value at pInt, and if they are the same, sets pInt to newValue and returns true with outResultValue set to newValue.  If they are different then pInt is unaffected, and returns false with outResultValue set to the value that was found at pInt.
    inline bool AtomicCompareExchange(volatile uint *pInt, uint expectedValue, uint newValue, volatile uint &outResultValue)
    {
        volatile uint changed=0; //why does this need volatile? it fixes the return bug...
        uint rval;
        asm(
             "lock cmpxchgl %4, (%2);"
             "jnz AtomCmpExch_Diff%=;"
             "movl %4, %%eax;"
             "incl %1;"
             "AtomCmpExch_Diff%=:;"
             "movl %%eax, %0;"
            :"=g"(rval), "=g"(changed)
            :"r"(pInt), "a"(expectedValue), "r"(newValue)
            :"memory", "cc");

        outResultValue=rval;
        return changed!=0;
    }

}; //namespace MPMA

---