C:/rwlock/atomic_util_lnx.h

Go to the documentation of this file.

#ifndef __ATOMIC_PRIMITIVES_LINUX_H_INCLUDDED__
#define __ATOMIC_PRIMITIVES_LINUX_H_INCLUDDED__

#ifndef SMP
#define SMP
#endif

#ifdef SMP
#define CPU_LOCK "lock; "
#else
#define CPU_LOCK
#endif

#define VOLATILE_PREF __volatile__

//#define VOLATILE_PREF

typedef struct { volatile int counter; } atomic_t;

static __inline__ void atomic_inc(atomic_t *vptr)       
{
        __asm__ VOLATILE_PREF (CPU_LOCK "incl %0"
                              : "=m" (vptr->counter) );
}
static __inline__ void atomic_dec(atomic_t *vptr)       
{
        __asm__ VOLATILE_PREF (CPU_LOCK "decl %0"
                              : "=m" (vptr->counter) );
}                                                       
static __inline__ void atomic_add(atomic_t *vptr, const int additive)
{
        __asm__ VOLATILE_PREF (CPU_LOCK "addl %1, %0"
                              : "=m" (vptr->counter)
                              : "r" (additive) );
}
static __inline__ void atomic_and(atomic_t *vptr, const int par)
{
        __asm__ VOLATILE_PREF (CPU_LOCK "andl %1, %0"
                              : "=m" (vptr->counter)
                              : "r" (par) );
}
static __inline__ int atomic_inc_return(atomic_t *vptr) 
{
    int ret;
        __asm__  VOLATILE_PREF("movl $1, %1; " CPU_LOCK "xaddl %1, %0; incl %1"
                          : "=m" (vptr->counter), "=a" (ret)
                          );
        return ret;
}
static __inline__ int atomic_dec_return(atomic_t *vptr) 
{
    int ret;
        __asm__ VOLATILE_PREF ( "movl $-1, %1; " CPU_LOCK "xaddl %1, %0; decl %1"
                          : "=m" (vptr->counter), "=a" (ret)
                           );
        return ret;
}

static __inline__ int atomic_add_return(atomic_t *vptr, int additive)
{
        __asm__ VOLATILE_PREF ( CPU_LOCK "xaddl %1, %0"
                          : "=m" (vptr->counter), "=a" (additive)
                          : "m" (vptr->counter), "a" (additive) );
        return additive;
}

static __inline__ int atomic_cmpexch_return(atomic_t *vptr, const int new_val, int comparand)
{
        __asm__ VOLATILE_PREF (CPU_LOCK "cmpxchgl %2, %0"
                              : "=m" (vptr->counter), "=a" (comparand)
                              : "r" (new_val), "a" (comparand)
                              : "1" );
        return comparand;
}

#define atomic_cmpexch  atomic_cmpexch_return

inline void atomic_inc(volatile int *vptr)
{
    atomic_inc((atomic_t *)vptr);
}

inline void atomic_dec(volatile int *vptr)
{
    atomic_dec((atomic_t *)vptr);
}

inline void atomic_add(volatile int *vptr, const int additive)
{
    atomic_add((atomic_t *)vptr, additive);
}
inline int atomic_inc_return(volatile int *vptr)
{
    return atomic_inc_return((atomic_t*)vptr);
}

inline int atomic_dec_return(volatile int *vptr)        
{
    return atomic_dec_return((atomic_t*)vptr);
}

inline int atomic_add_return(volatile int *vptr, int additive)
{
    return   atomic_add_return((atomic_t *)vptr, additive);
}

inline int atomic_cmpexch_return(volatile int *v, const int new_val, int comparand)
{
    return atomic_cmpexch_return((atomic_t *)v, new_val, comparand);
}

inline void atomic_and(volatile int *vptr, const int par)
{
        atomic_and((atomic_t *)vptr, par);
}

#endif // #ifndef __ATOMIC_PRIMITIVES_LINUX_H_INCLUDDED__

---