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
        {
            mov eax, pint;
            lock inc dword ptr [eax];
        }
    }

    //Atomically decrements an integer
    inline void AtomicIntDec(volatile uint *pint)
    {
        __asm
        {
            mov eax, pint;
            lock dec dword ptr [eax];
        }
    }
    
    //Atomically adds one integer to another and returns the value of the original
    inline int AtomicIntAdd(volatile int *pint, int addValue)
    {
        int rval;
        __asm
        {
            mov eax, addValue;
            mov ebx, pint;
            lock xadd dword ptr [ebx], eax;
            mov rval, eax;
        }
        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)
    {
        uint rval;
        uint changed=0;
        __asm
        {
            mov eax, expectedValue;
            mov ebx, pInt;
            mov ecx, newValue;
            lock cmpxchg [ebx], ecx;
            jnz AtomCmpExch_Diff;
            mov eax,ecx;
            inc changed;
            AtomCmpExch_Diff:
            mov rval, eax;
        }
        outResultValue=rval;
        return changed!=0;;
    }

}; //namespace Platform

---