C:/rwlock/atomic_util_w32.h

Go to the documentation of this file.

#ifndef __ATOMIC_PRIMITIVES_W32_H_INCLUDDED__
#define __ATOMIC_PRIMITIVES_W32_H_INCLUDDED__

#define _ATOMIC_UTIL_USE_ASM_

#ifdef _ATOMIC_UTIL_USE_ASM_
 #define _ATOMIC_UTIL_SMP_
 #ifdef _ATOMIC_UTIL_SMP_
  #define CPU_LOCK lock
 #else 
  #define CPU_LOCK
 #endif // _ATOMIC_UTIL_SMP_

/*
#define atomic_inc(v)           __asm { \
                                                        __asm mov eax, v \
                                                        __asm lock inc [eax] }
                                                        
#define atomic_dec(v)           __asm { \
                                                        __asm mov eax, v \
                                                        __asm lock dec [eax] }
                                                        
#define atomic_add(v, a)        __asm { \
                                                        __asm mov ebx, a \
                                                        __asm lock add v, ebx }
*/
inline void atomic_inc(volatile int *vptr)      
{
        __asm 
        { 
                        mov eax, vptr
                        lock inc [eax]
        }
}
inline void atomic_dec(volatile int *vptr)      
{
        __asm 
        { 
                        mov eax, vptr
                        lock dec [eax]
        }
}                                                       
inline void atomic_add(volatile int *vptr, const int additive)
{
        __asm 
        { 
                        mov eax, vptr
                        mov ebx, additive
                        lock add [eax], ebx
        }
}
inline void atomic_and(volatile int *vptr, const int param)
{
        __asm 
        { 
                        mov eax, vptr
                        mov ebx, param
                        lock and [eax], ebx
        }
}
inline int atomic_inc_return(volatile int *vptr)        
{
        __asm 
        { 
                        mov ebx, vptr
                        mov eax, 1
                        lock xadd [ebx], eax
                        inc eax
        }
}
inline int atomic_dec_return(volatile int *vptr)        
{
        __asm 
        { 
                        mov ebx, vptr
                        mov eax, -1
                        lock xadd [ebx], eax
                        dec eax
        }
}
inline int atomic_add_return(volatile int *vptr, const int additive)
{
        __asm 
        { 
                        mov ebx, vptr
                        mov eax, additive
                        lock xadd [ebx], eax
        }
}
inline int atomic_cmpexch_return(volatile int *vptr, const int new_val, const int comparand)
{
        __asm 
        { 
                        mov eax, comparand
                        mov ebx, new_val
                        mov ecx, vptr
                        lock cmpxchg [ecx], ebx
        }
}
inline short atomic_cmpexch_return_w(volatile short *vptr, const short new_val, const short comparand)
{
        __asm 
        { 
                        mov ax, comparand
                        mov bx, new_val
                        mov ecx, vptr
                        lock cmpxchg [ecx], bx
        }
}

#define atomic_cmpexch  atomic_cmpexch_return

#else // _ATOMIC_UTIL_USE_ASM_
inline long atomic_inc_return(volatile long *v) { return InterlockedIncrement(v); }
inline long atomic_dec_return(volatile long *v) { return InterlockedDecrement(v); }

inline long atomic_add_return(volatile long *vptr, const long additive)
{ return InterlockedExchangeAdd(vptr, additive); }

inline long atomic_cmpexch_return(volatile long *vptr, const long new_val, const long comparand)
{ return InterlockedCompareExchange(vptr, new_val, comparand ); }

#define atomic_add              atomic_add_return
#define atomic_inc              atomic_inc_return
#define atomic_dec              atomic_dec_return
#define atomic_cmpexch  atomic_cmpexch_return

#endif // _ATOMIC_UTIL_USE_ASM_
#endif // __ATOMIC_PRIMITIVES_W32_H_INCLUDDED__

---