00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00038 #include "blocxx/BLOCXX_config.h"
00039 #include "blocxx/AtomicOps.hpp"
00040
00041 #if defined(BLOCXX_USE_PTHREAD_SPIN_LOCK_ATOMIC_OPS)
00042
00043 namespace BLOCXX_NAMESPACE
00044 {
00045
00046 Atomic_t::Atomic_t()
00047 : val(0)
00048 {
00049 pthread_spin_init(&spinlock, 0);
00050 }
00051 Atomic_t::Atomic_t(int i)
00052 : val(i)
00053 {
00054 pthread_spin_init(&spinlock, 0);
00055 }
00056 void AtomicInc(Atomic_t &v)
00057 {
00058 pthread_spin_lock(&v.spinlock);
00059 ++v.val;
00060 pthread_spin_unlock(&v.spinlock);
00061 }
00062 bool AtomicDecAndTest(Atomic_t &v)
00063 {
00064 pthread_spin_lock(&v.spinlock);
00065 --v.val;
00066 bool b = ((v.val == 0) ? true : false) ;
00067 pthread_spin_unlock(&v.spinlock);
00068 return b;
00069 }
00070 int AtomicGet(Atomic_t const &v)
00071 {
00072 return v.val;
00073 }
00074 void AtomicDec(Atomic_t &v)
00075 {
00076 pthread_spin_lock(&v.spinlock);
00077 --v.val;
00078 pthread_spin_unlock(&v.spinlock);
00079 }
00080
00081 }
00082
00083 #elif defined(BLOCXX_USE_BLOCXX_DEFAULT_ATOMIC_OPS)
00084 #include "blocxx/Mutex.hpp"
00085 #include "blocxx/MutexLock.hpp"
00086 #include "blocxx/ThreadOnce.hpp"
00087
00088 namespace BLOCXX_NAMESPACE
00089 {
00090
00091
00092
00093
00094 static Mutex* guard = 0;
00095 static OnceFlag g_once = BLOCXX_ONCE_INIT;
00096 static void initGuard()
00097 {
00098 guard = new Mutex();
00099 }
00100 void AtomicInc(Atomic_t &v)
00101 {
00102 callOnce(g_once, initGuard);
00103 MutexLock lock(*guard);
00104 ++v.val;
00105 }
00106 bool AtomicDecAndTest(Atomic_t &v)
00107 {
00108 callOnce(g_once, initGuard);
00109 MutexLock lock(*guard);
00110 return --v.val == 0;
00111 }
00112 int AtomicGet(Atomic_t const &v)
00113 {
00114 callOnce(g_once, initGuard);
00115 MutexLock lock(*guard);
00116 return v.val;
00117 }
00118 void AtomicDec(Atomic_t &v)
00119 {
00120 callOnce(g_once, initGuard);
00121 MutexLock lock(*guard);
00122 --v.val;
00123 }
00124
00125 }
00126
00127 #endif
00128
00129