atomic_ix86.h

Go to the documentation of this file.

// Primary maintainer for this file: Rob Peters <rjpeters@klab.caltech.edu>
// $HeadURL: file:///lab/rjpeters/svnrepo/code/trunk/groovx/src/rutz/atomic_ix86.h $
// $Id: atomic_ix86.h 10031 2006-10-05 17:55:50Z rjpeters $

#ifndef RUTZ_ATOMIC_IX86_H_UTC20050728203342_DEFINED
#define RUTZ_ATOMIC_IX86_H_UTC20050728203342_DEFINED

namespace rutz
{

/*
 * Atomic operations that C can't guarantee us.  Useful for
 * resource counting etc..
 */

#define LOCK "lock ; "

/*
 * Make sure gcc doesn't try to be clever and move things around
 * on us. We need to use _exactly_ the address the user gave us,
 * not some alias that contains the same information.
 */
typedef struct { volatile int counter; } ix86_atomic_int_t;

#define ix86_atomic_read(v)          ((v)->counter)

#define ix86_atomic_set(v,i)         (((v)->counter) = (i))

static __inline__ void ix86_atomic_add(int i, ix86_atomic_int_t *v)
{
        __asm__ __volatile__(
                LOCK "addl %1,%0"
                :"=m" (v->counter)
                :"ir" (i), "m" (v->counter));
}

static __inline__ void ix86_atomic_sub(int i, ix86_atomic_int_t *v)
{
        __asm__ __volatile__(
                LOCK "subl %1,%0"
                :"=m" (v->counter)
                :"ir" (i), "m" (v->counter));
}

static __inline__ int ix86_atomic_sub_and_test(int i, ix86_atomic_int_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                LOCK "subl %2,%0; sete %1"
                :"=m" (v->counter), "=qm" (c)
                :"ir" (i), "m" (v->counter) : "memory");
        return c;
}

static __inline__ void ix86_atomic_inc(ix86_atomic_int_t *v)
{
        __asm__ __volatile__(
                LOCK "incl %0"
                :"=m" (v->counter)
                :"m" (v->counter));
}

static __inline__ void ix86_atomic_dec(ix86_atomic_int_t *v)
{
        __asm__ __volatile__(
                LOCK "decl %0"
                :"=m" (v->counter)
                :"m" (v->counter));
}

static __inline__ int ix86_atomic_dec_and_test(ix86_atomic_int_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                LOCK "decl %0; sete %1"
                :"=m" (v->counter), "=qm" (c)
                :"m" (v->counter) : "memory");
        return c != 0;
}

static __inline__ int ix86_atomic_inc_and_test(ix86_atomic_int_t *v)
{
        unsigned char c;

        __asm__ __volatile__(
                LOCK "incl %0; sete %1"
                :"=m" (v->counter), "=qm" (c)
                :"m" (v->counter) : "memory");
        return c != 0;
}

static __inline__ int ix86_atomic_add_return(int i, ix86_atomic_int_t *v)
{
        /* Modern 486+ processor */
        int __i = i;
        __asm__ __volatile__(
                LOCK "xaddl %0, %1;"
                :"=r"(i)
                :"m"(v->counter), "0"(i));
        return i + __i;
}

static __inline__ int ix86_atomic_sub_return(int i, ix86_atomic_int_t *v)
{
        return ix86_atomic_add_return(-i,v);
}

class ix86_atomic_int
{
private:
  ix86_atomic_int_t x;

  ix86_atomic_int(const ix86_atomic_int&); // not implemented
  ix86_atomic_int& operator=(const ix86_atomic_int&); // not implemented

public:
  ix86_atomic_int() { this->atomic_set(0); }

  static int max_value() { return ((1 << 24) - 1); }

  int atomic_get() const
  { return ix86_atomic_read(&x); }

  void atomic_set(int v)
  { ix86_atomic_set(&x, v); }

  void atomic_add(int i)
  { ix86_atomic_add(i, &x); }

  void atomic_sub(int i)
  { ix86_atomic_sub(i, &x); }

  bool atomic_sub_test_zero(int i)
  { return bool(ix86_atomic_sub_and_test(i, &x)); }

  void atomic_incr()
  { ix86_atomic_inc(&x); }

  void atomic_decr()
  { ix86_atomic_dec(&x); }

  bool atomic_decr_test_zero()
  { return bool(ix86_atomic_dec_and_test(&x)); }

  bool atomic_incr_test_zero()
  { return bool(ix86_atomic_inc_and_test(&x)); }

  int atomic_add_return(int i)
  { return ix86_atomic_add_return(i, &x); }

  int atomic_sub_return(int i)
  { return ix86_atomic_sub_return(i, &x); }

  int atomic_incr_return()
  { return ix86_atomic_add_return(1, &x); }

  int atomic_decr_return()
  { return ix86_atomic_add_return(-1, &x); }
};

} // end namespace rutz

#endif // !RUTZ_ATOMIC_IX86_H_UTC20050728203342DEFINED

---

The software described here is Copyright (c) 1998-2005, Rob Peters.
This page was generated Wed Dec 3 06:49:40 2008 by Doxygen version 1.5.5.