atom.h

Go to the documentation of this file.

 //*****************************************************************************


 // Copyright 1986, 2014 NVIDIA Corporation. All rights reserved.


 //*****************************************************************************


 //*****************************************************************************


 

 #ifndef MI_BASE_ATOM_H


 #define MI_BASE_ATOM_H


 


 #include <mi/base/config.h>


 #include <mi/base/types.h>


 

 //


 // Check what version of implementation we can use


 //


 

 #if defined(MI_ARCH_X86) && defined(MI_COMPILER_MSC)


 #  define MI_ATOM32_X86MSC


 #  include <intrin.h>


 #  pragma intrinsic (_InterlockedExchangeAdd)


 #  pragma intrinsic (_InterlockedCompareExchange)


 #elif defined(MI_ARCH_X86) && (defined(MI_COMPILER_GCC) || defined(MI_COMPILER_ICC))


 #  define MI_ATOM32_X86GCC


 #else


 #  define MI_ATOM32_GENERIC


 #  include <mi/base/lock.h>


 #endif


 


 namespace mi {

 namespace base {

 

 class Atom32

 {

 public:

     Atom32() : m_atom(0) {}

 

     Atom32(const Uint32 val) : m_atom(val) {}

 

     Uint32 operator = (const Uint32 val) {

         m_atom = val;

         return val;

     }

 

     Uint32 operator += (const Uint32 val);

 

     Uint32 operator -= (const Uint32 val);

 

     Uint32 operator ++();

 

     Uint32 operator ++(int);

 

     Uint32 operator --();

 

     Uint32 operator --(int);

 

     operator Uint32 () const {

         return m_atom;

     }

 

     Uint32 swap(const Uint32 val);

 

 private:

     volatile Uint32 m_atom;

 

 #if defined(MI_ATOM32_GENERIC)


     mi::base::Lock m_lock;

 #endif


 };

 

 #if defined(MI_ATOM32_X86MSC)


 


 //


 // operator +=


 //


 __forceinline Uint32 Atom32::operator += ( const Uint32 rhs) {

     return _InterlockedExchangeAdd(reinterpret_cast<volatile long *>(&m_atom),rhs) + rhs;

 }

 

 //


 // operator -=


 //


 __forceinline Uint32 Atom32::operator -= ( const Uint32 rhs) {

     return _InterlockedExchangeAdd(

         reinterpret_cast<volatile long *>(&m_atom), -static_cast<const Sint32>(rhs)) - rhs;

 }

 

 //


 // operator ++


 //


 __forceinline Uint32 Atom32::operator ++() {

     return _InterlockedExchangeAdd(reinterpret_cast<volatile long *>(&m_atom),1L) + 1L;

 }

 

 //


 // operator --


 //


 __forceinline Uint32 Atom32::operator --() {

     return _InterlockedExchangeAdd(reinterpret_cast<volatile long *>(&m_atom),-1L) - 1L;

 }

 

 //


 // operator ++


 //


 __forceinline Uint32 Atom32::operator ++(int) {

     return _InterlockedExchangeAdd(reinterpret_cast<volatile long *>(&m_atom),1L);

 }

 

 //


 // operator --


 //


 __forceinline Uint32 Atom32::operator --(int) {

     return _InterlockedExchangeAdd(reinterpret_cast<volatile long *>(&m_atom),-1L);

 }

 

 //


 // atomic value swapper


 //


 __forceinline Uint32 Atom32::swap( const Uint32 rhs) {

     return _InterlockedExchange(reinterpret_cast<volatile long *>(&m_atom),rhs);

 }

 

 #elif defined(MI_ATOM32_X86GCC) // defined(MI_ATOM32_X86MSC)


 


 //


 // operator +=


 //


 inline Uint32 Atom32::operator += ( const Uint32 rhs) {

     Uint32 retval;

     asm volatile (

         "movl %2,%0\n"


         "lock; xaddl %0,%1\n"


         "addl %2,%0\n"


         : "=&r" (retval), "+m" (m_atom)

         : "r" (rhs)

         : "cc"


         );

     return retval;

 }

 

 //


 // operator -=


 //


 inline Uint32 Atom32::operator -= ( const Uint32 rhs) {

     Uint32 retval;

     asm volatile (

         "neg %2\n"


         "movl %2,%0\n"


         "lock; xaddl %0,%1\n"


         "addl %2,%0\n"


         : "=&r" (retval), "+m" (m_atom)

         : "r" (rhs)

         : "cc", "%2"


         );

     return retval;

 }

 

 //


 // operator ++


 //


 inline Uint32 Atom32::operator ++() {

     Uint32 retval;

     asm volatile (

         "movl $1,%0\n"


         "lock; xaddl %0,%1\n"


         "addl $1,%0\n"


         : "=&r" (retval), "+m" (m_atom)

         :

         : "cc"


         );

     return retval;

 }

 

 //


 // operator --


 //


 inline Uint32 Atom32::operator --() {

     Uint32 retval;

     asm volatile (

         "movl $-1,%0\n"


         "lock; xaddl %0,%1\n"


         "addl $-1,%0\n"


         : "=&r" (retval), "+m" (m_atom)

         :

         : "cc"


         );

     return retval;

 }

 

 //


 // operator ++


 //


 inline Uint32 Atom32::operator ++(int) {

     Uint32 retval;

     asm volatile (

         "movl $1,%0\n"


         "lock; xaddl %0,%1\n"


         : "=&r" (retval), "+m" (m_atom)

         :

         : "cc"


         );

     return retval;

 }

 

 //


 // operator --


 //


 inline Uint32 Atom32::operator --(int) {

     Uint32 retval;

     asm volatile (

         "movl $-1,%0\n"


         "lock; xaddl %0,%1\n"


         : "=&r" (retval), "+m" (m_atom)

         :

         : "cc"


         );

     return retval;

 }

 

 //


 // atomic value swapper


 //


 inline Uint32 Atom32::swap( const Uint32 rhs) {

     Uint32 retval;

     asm volatile (

     "0:\n"


         "movl %1,%0\n"


         "lock; cmpxchg %2,%1\n"


         "jnz 0b\n"


         : "=&a" (retval), "+m" (m_atom)

         : "r" (rhs)

         : "cc"


         );

     return retval;

 }

 

 #elif defined(MI_ATOM32_GENERIC) // defined(MI_ATOM32_X86GCC)


 


 //


 // operator +=


 //


 inline Uint32 Atom32::operator += ( const Uint32 rhs) {

     mi::base::Lock::Block block(&m_lock);

     return m_atom += rhs;

 }

 

 //


 // operator -=


 //


 inline Uint32 Atom32::operator -= ( const Uint32 rhs) {

     mi::base::Lock::Block block(&m_lock);

     return m_atom -= rhs;

 }

 

 //


 // operator ++


 //


 inline Uint32 Atom32::operator ++() {

     mi::base::Lock::Block block(&m_lock);

     return ++m_atom;

 }

 

 //


 // operator --


 //


 inline Uint32 Atom32::operator --() {

     mi::base::Lock::Block block(&m_lock);

     return --m_atom;

 }

 

 //


 // operator ++


 //


 inline Uint32 Atom32::operator ++(int) {

     mi::base::Lock::Block block(&m_lock);

     return m_atom++;

 }

 

 //


 // operator --


 //


 inline Uint32 Atom32::operator --(int) {

     mi::base::Lock::Block block(&m_lock);

     return m_atom--;

 }

 

 //


 // atomic value swap operation


 //


 inline Uint32 Atom32::swap( const Uint32 rhs) {

     mi::base::Lock::Block block(&m_lock);

     Uint32 retval = m_atom;

     m_atom = rhs;

     return retval;

 }

 

 #else // MI_ATOM32_GENERIC


 #error One of MI_ATOM32_X86MSC, MI_ATOM32_X86GCC, or MI_ATOM32_GENERIC must be defined. 


 #endif


 


 #undef MI_ATOM32_X86MSC


 #undef MI_ATOM32_X86GCC


 #undef MI_ATOM32_GENERIC


  // end group mi_base_threads


 

 } // namespace base


 } // namespace mi


 

 #endif // MI_BASE_ATOM_H