00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016 #ifndef UTILS_H
00017 #define UTILS_H
00018
00019 using namespace std;
00020 #include <iostream>
00021 #include <cstdlib>
00022 #include <cstring>
00023 #include <sstream>
00024 #include <cerrno>
00025 #include <asm/atomic.h>
00026 #include <signal.h>
00027 #include <sys/sem.h>
00028
00041
00042 typedef void sigfunc(int);
00043
00045 typedef atomic_t tAtomicLock;
00046
00048 struct tAtomicRWLock {
00049 atomic_t lock;
00050 atomic_t readcount;
00051 };
00052
00053 void debugprint(char relevance, string subject, string func = "");
00054 void debugprintunix(char relevance, string subject, string func = "");
00055 string int2str(int value);
00056 string ptr2str(void* pointer);
00057 unsigned long crc32(const char *string);
00058 unsigned long crc32(const char *buffer, unsigned long len);
00059 unsigned long crc32(string str);
00060 sigfunc* setsignalhandler(int signo, sigfunc* newfunc);
00061 int semaphore_create(bool master = false, string name = "", int mode = 0666);
00062 void semaphore_remove(int semid);
00063 void semaphore_wait(int semid, int change = -1);
00064 void semaphore_signal(int semid);
00065 int semaphore_getvalue(int semid);
00066
00067
00068
00071 inline void atomic_setunlocked(atomic_t* lockvar) {
00072 atomic_set(lockvar, 1);
00073 }
00074
00078 inline void atomic_lock(atomic_t* lockvar) {
00079
00080 while (!atomic_dec_and_test(lockvar)) {
00081
00082 atomic_inc(lockvar);
00083
00084 if (sched_yield()==-1)
00085 debugprintunix('E',"error yielding process", "atomic_lock");
00086 }
00087 }
00088
00091 inline void atomic_unlock(atomic_t* lockvar) {
00092 atomic_inc(lockvar);
00093 }
00094
00095
00096 inline void atomic_rwlock_setunlocked(tAtomicRWLock* lockvar) {
00099 atomic_setunlocked(&(lockvar->lock));
00100 atomic_set(&(lockvar->readcount), 1);
00101 };
00102
00106 inline void atomic_readlock_acquire(tAtomicRWLock* lockvar) {
00108 atomic_lock(&(lockvar->lock));
00110 atomic_inc(&(lockvar->readcount));
00112 atomic_unlock(&(lockvar->lock));
00113 }
00114
00118 inline void atomic_readlock_release(tAtomicRWLock* lockvar) {
00119 if (atomic_dec_and_test(&(lockvar->readcount)))
00120 debugprint('E', "decrementing read count more often than incrementing it", "atomic_readlock_release");
00121 }
00122
00126 inline void atomic_writelock_acquire(tAtomicRWLock* lockvar) {
00128 atomic_lock(&(lockvar->lock));
00130 atomic_lock(&(lockvar->readcount));
00131 atomic_unlock(&(lockvar->readcount));
00132 }
00133
00136 inline void atomic_writelock_release(tAtomicRWLock* lockvar) {
00137 atomic_unlock(&(lockvar->lock));
00138 }
00139
00142 inline void atomic_writelock_upgrade(tAtomicRWLock* lockvar) {
00144 atomic_lock(&(lockvar->lock));
00146 atomic_readlock_release(lockvar);
00148 atomic_lock(&(lockvar->readcount));
00149 atomic_unlock(&(lockvar->readcount));
00150 }
00151
00154 inline void atomic_writelock_downgrade(tAtomicRWLock* lockvar) {
00155 atomic_inc(&(lockvar->readcount));
00156 atomic_writelock_release(lockvar);
00157 }
00158
00159 #endif