/ray/src/lib/threads/atomic.h

Go to the documentation of this file.

/*
 * lib/threads/atomic.h
 * 
 * Atomic counters for threaded applications. 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#ifndef _ThreadLibrary_Atomic_H_
#define _ThreadLibrary_Atomic_H_ 1

#include <lib/sconfig.h>    /* MUST be first */

/* See if we have an asm/atomic.h and can use fast atomic operations. */
#if USE_PRIVATE__ATOMIC
# if HAVE_ASM_ATOMIC_H
#  include <asm/atomic.h>
# elif HAVE_ATOMIC_H
#  include <atomic.h>
# endif
#else
#include <lib/threads/mutex.h>
#include <glib/gthread.h>
#endif


// Atomic integer with atomic operations that C can't guarantee us. 
// Useful for resource counting etc...
class _packed_ AtomicInt
{
    private:
#if USE_PRIVATE__ATOMIC
        atomic_t v;
#else
        // It seems, the GLib people somehow forgot to provide 
        // this functionality. Or I simply have no clue on how to 
        // properly exploit the exchange functions. 
        // So, we need a mutex in these cases. 
        FastMutex m;
        gint v;  
#endif
        
    public:
        inline AtomicInt(int initial=0)
#if USE_PRIVATE__ATOMIC
            {  atomic_set(&v,initial);  }
#else
            : m()  {  v=initial;  }
#endif
        inline ~AtomicInt() {}
        
        inline int val() const
#if USE_PRIVATE__ATOMIC
            {  return(atomic_read(&v));  }
#else
            {  return(g_atomic_int_get(&v));  }
#endif
        inline operator int() const  {  return(val());  }
        
        inline void set(int i)
#if USE_PRIVATE__ATOMIC
            {  atomic_set(&v,i);  }
#else
            {  m.lock();  v=i;  m.unlock();  }
#endif
        inline void operator=(int i)  {  set(i);  }
        
        inline void inc()
#if USE_PRIVATE__ATOMIC
            {  atomic_inc(&v);  }
#else
            //{  g_atomic_int_add(&v,1);  }
            {  m.lock();  ++v;  m.unlock();  }
#endif
        inline void operator++()  {  inc();  }
        
        inline void dec()
#if USE_PRIVATE__ATOMIC
            {  atomic_dec(&v);  }
#else
            //{  g_atomic_int_add(&v,-1);  }
            {  m.lock();  --v;  m.unlock();  }
#endif
        inline void operator--()  {  dec();  }
        
        inline bool DecAndTest()
#if USE_PRIVATE__ATOMIC
            {  return(atomic_dec_and_test(&v));  }
#else
            {  m.lock();  bool rv=--v==0;  m.unlock();  return(rv);  }
#endif
        
        inline void add(int i)
#if USE_PRIVATE__ATOMIC
            {  atomic_add(i,&v);  }
#else
            //{  g_atomic_int_add(&v,i);  }
            {  m.lock();  v+=i;  m.unlock();  }
#endif
        inline void operator+=(int i)  {  add(i);  }
        
        inline void sub(int i)
#if USE_PRIVATE__ATOMIC
            {  atomic_sub(i,&v);  }
#else
            {  add(-i);  }
#endif
        inline void operator-=(int i)  {  sub(i);  }
        
        inline bool SubAndTest(int i)
#if USE_PRIVATE__ATOMIC
            {  return(atomic_sub_and_test(i,&v));  }
#else
            {  m.lock();  v-=i;  bool rv=v==0;  m.unlock();  return(rv);  }
#endif
        
};

#endif  /* _ThreadLibrary_Atomic_H_ */

---