diff --git a/configure.ac b/configure.ac index 9e0e43e30..34091e389 100644 --- a/configure.ac +++ b/configure.ac @@ -92,7 +92,7 @@ AC_CHECK_HEADER([execinfo.h], AC_DEFINE(HAVE_EXECINFO_H)) PKG_CHECK_MODULES(VALGRIND, [valgrind], AC_DEFINE(HAVE_VALGRIND_H), AC_MSG_NOTICE([valgrind not found (optional)])) -PKG_CHECK_MODULES(NOBUGMT, [nobugmt >= 201001.2], +PKG_CHECK_MODULES(NOBUGMT, [nobugmt >= 201002.1], AC_DEFINE(HAVE_NOBUGMT_H), AC_MSG_ERROR([Missing required nobug version (http://www.lumiera.org/nobug_manual.html)]) ) diff --git a/src/backend/file.c b/src/backend/file.c index cd22d00ba..8302f9149 100644 --- a/src/backend/file.c +++ b/src/backend/file.c @@ -95,7 +95,6 @@ lumiera_file_handle_acquire (LumieraFile self) TRACE (file_dbg); REQUIRE (self); REQUIRE (self->descriptor); - REQUIRE (lumiera_fhcache); return lumiera_filedescriptor_handle_acquire (self->descriptor); } @@ -107,7 +106,6 @@ lumiera_file_handle_release (LumieraFile self) TRACE (file_dbg); REQUIRE (self); REQUIRE (self->descriptor); - REQUIRE (lumiera_fhcache); return lumiera_filedescriptor_handle_release (self->descriptor); } diff --git a/src/backend/filedescriptor.c b/src/backend/filedescriptor.c index 876fc0768..849b2cd84 100644 --- a/src/backend/filedescriptor.c +++ b/src/backend/filedescriptor.c @@ -214,9 +214,9 @@ lumiera_filedescriptor_handle_acquire (LumieraFiledescriptor self) { if (!self->handle) /* no handle yet, get a new one */ - lumiera_filehandlecache_handle_acquire (lumiera_fhcache, self); + lumiera_filehandlecache_handle_acquire (self); else - lumiera_filehandlecache_checkout (lumiera_fhcache, self->handle); + lumiera_filehandlecache_checkout (self->handle); fd = lumiera_filehandle_handle (self->handle); } @@ -232,7 +232,7 @@ lumiera_filedescriptor_handle_release (LumieraFiledescriptor self) REQUIRE (self->handle); LUMIERA_MUTEX_SECTION (mutex_sync, &self->lock) - lumiera_filehandlecache_checkin (lumiera_fhcache, self->handle); + lumiera_filehandlecache_checkin (self->handle); } @@ -299,11 +299,11 @@ lumiera_filedescriptor_delete (LumieraFiledescriptor self, const char* name) if (self->handle && name && ((self->flags & O_RDWR) == O_RDWR)) { TRACE (filedescriptor_dbg, "truncate %s to %lld", name, (long long)self->realsize); - lumiera_filehandlecache_checkout (lumiera_fhcache, self->handle); + lumiera_filehandlecache_checkout (self->handle); int dummy = ftruncate (lumiera_filehandle_handle (self->handle), self->realsize); (void) dummy; /* this is present to silence a warning */ TODO ("handle error case better"); - lumiera_filehandlecache_checkin (lumiera_fhcache, self->handle); + lumiera_filehandlecache_checkin (self->handle); } lumiera_mmapings_delete (self->mmapings); diff --git a/src/backend/filehandlecache.c b/src/backend/filehandlecache.c index f2cf4623b..2f5002e58 100644 --- a/src/backend/filehandlecache.c +++ b/src/backend/filehandlecache.c @@ -64,21 +64,21 @@ lumiera_filehandlecache_delete (void) LumieraFilehandle -lumiera_filehandlecache_handle_acquire (LumieraFilehandlecache self, LumieraFiledescriptor desc) +lumiera_filehandlecache_handle_acquire (LumieraFiledescriptor desc) { TRACE (filehandlecache_dbg); LumieraFilehandle ret = NULL; - LUMIERA_MUTEX_SECTION (mutex_sync, &self->lock) + LUMIERA_MUTEX_SECTION (mutex_sync, &lumiera_fhcache->lock) { - if (self->available <= 0 && self->cache.cached) + if (lumiera_fhcache->available <= 0 && lumiera_fhcache->cache.cached) { /* pop a filehandle from cache */ - ret = lumiera_mrucache_pop (&self->cache); - ret = lumiera_filehandle_init (lumiera_mrucache_pop (&self->cache), desc); - if (self->available < 0) + ret = lumiera_mrucache_pop (&lumiera_fhcache->cache); + ret = lumiera_filehandle_init (lumiera_mrucache_pop (&lumiera_fhcache->cache), desc); + if (lumiera_fhcache->available < 0) /* try to free overallocated filehandles */ - self->available -= self->available + lumiera_mrucache_age (&self->cache, -self->available); + lumiera_fhcache->available -= lumiera_fhcache->available + lumiera_mrucache_age (&lumiera_fhcache->cache, -lumiera_fhcache->available); } else { @@ -89,51 +89,49 @@ lumiera_filehandlecache_handle_acquire (LumieraFilehandlecache self, LumieraFile if (!ret) LUMIERA_ERROR_SET_ALERT (file, FILEHANDLECACHE_NOHANDLE, lumiera_filedescriptor_name (desc)); else - --self->available; + --lumiera_fhcache->available; } desc->handle = ret; - ++self->checked_out; + ++lumiera_fhcache->checked_out; } return ret; } LumieraFilehandle -lumiera_filehandlecache_checkout (LumieraFilehandlecache self, LumieraFilehandle handle) +lumiera_filehandlecache_checkout (LumieraFilehandle handle) { - REQUIRE (self); REQUIRE (handle); /* This function is called with the associated descriptor locked, nothing can modify 'handle' */ if (!handle->use_cnt) { /* lock cache and checkout */ - LUMIERA_MUTEX_SECTION (mutex_sync, &self->lock) + LUMIERA_MUTEX_SECTION (mutex_sync, &lumiera_fhcache->lock) { - lumiera_mrucache_checkout (&self->cache, &handle->cachenode); + lumiera_mrucache_checkout (&lumiera_fhcache->cache, &handle->cachenode); } } ++handle->use_cnt; - ++self->checked_out; + ++lumiera_fhcache->checked_out; return handle; } void -lumiera_filehandlecache_checkin (LumieraFilehandlecache self, LumieraFilehandle handle) +lumiera_filehandlecache_checkin (LumieraFilehandle handle) { - REQUIRE (self); REQUIRE (handle); REQUIRE (handle->use_cnt); - /* This function is called with the associated descriptor locked, nothing can modify 'self' */ + /* This function is called with the associated descriptor locked, nothing can modify the fhcache */ if (!--handle->use_cnt) { /* lock cache and checin */ - LUMIERA_MUTEX_SECTION (mutex_sync, &self->lock) + LUMIERA_MUTEX_SECTION (mutex_sync, &lumiera_fhcache->lock) { - --self->checked_out; - lumiera_mrucache_checkin (&self->cache, &handle->cachenode); + --lumiera_fhcache->checked_out; + lumiera_mrucache_checkin (&lumiera_fhcache->cache, &handle->cachenode); } } } diff --git a/src/backend/filehandlecache.h b/src/backend/filehandlecache.h index 41030425d..29a023b17 100644 --- a/src/backend/filehandlecache.h +++ b/src/backend/filehandlecache.h @@ -51,8 +51,6 @@ struct lumiera_filehandlecache_struct lumiera_mutex lock; }; -extern LumieraFilehandlecache lumiera_fhcache; - /** * Initializes the filehandle cache. * @param max_entries number how much filehandles shall be managed @@ -76,7 +74,7 @@ lumiera_filehandlecache_delete (void); * @return the new filehandle */ LumieraFilehandle -lumiera_filehandlecache_handle_acquire (LumieraFilehandlecache self, LumieraFiledescriptor desc); +lumiera_filehandlecache_handle_acquire (LumieraFiledescriptor desc); /** * Remove a filehandle from cache aging @@ -85,7 +83,7 @@ lumiera_filehandlecache_handle_acquire (LumieraFilehandlecache self, LumieraFile * @param handle the filehandle to be checked out */ LumieraFilehandle -lumiera_filehandlecache_checkout (LumieraFilehandlecache self, LumieraFilehandle handle); +lumiera_filehandlecache_checkout (LumieraFilehandle handle); /** * Put a filehandle into the cache @@ -94,6 +92,6 @@ lumiera_filehandlecache_checkout (LumieraFilehandlecache self, LumieraFilehandle * @param handle the filehandle to be checked in */ void -lumiera_filehandlecache_checkin (LumieraFilehandlecache self, LumieraFilehandle handle); +lumiera_filehandlecache_checkin (LumieraFilehandle handle); #endif diff --git a/src/backend/thread-wrapper.hpp b/src/backend/thread-wrapper.hpp index 43cf9cab1..ab64939c9 100644 --- a/src/backend/thread-wrapper.hpp +++ b/src/backend/thread-wrapper.hpp @@ -96,6 +96,7 @@ namespace backend { : operation_(operation_to_execute) { REQUIRE (!lumiera_error(), "Error pending at thread start") ; + TODO("the threadclass needs to become a parameter"); handle = lumiera_thread_run ( LUMIERA_THREADCLASS_INTERACTIVE | additionalFlags , &run // invoking the run helper and.. @@ -200,9 +201,10 @@ namespace backend { lumiera_err errorInOtherThread = lumiera_thread_join (thread_); thread_ = 0; - + + TODO("check this, is error::State approbiate or do we want Runtime as thrown by throwOnError()"); if (errorInOtherThread) - throw lumiera::error::State ("Thread terminated with error:"); + throw lumiera::error::State ("Thread terminated with error:", errorInOtherThread); } }; diff --git a/src/backend/threads.c b/src/backend/threads.c index 0b97ed880..f4e379354 100644 --- a/src/backend/threads.c +++ b/src/backend/threads.c @@ -107,6 +107,8 @@ thread_loop (void* thread) /* move error state to data the other thread will it pick up from there */ t->arguments = (void*)lumiera_error (); t->state = LUMIERA_THREADSTATE_ZOMBIE; + ERROR_IF (t->arguments, threads, "joinable thread ended with error %s", (char*)t->arguments); + LUMIERA_CONDITION_SIGNAL; LUMIERA_CONDITION_WAIT (t->state == LUMIERA_THREADSTATE_JOINED); INFO (threads, "Thread joined"); @@ -341,6 +343,8 @@ lumiera_thread_join (LumieraThread thread) { LUMIERA_CONDITION_WAIT (thread->state == LUMIERA_THREADSTATE_ZOMBIE); ret = (lumiera_err)thread->arguments; + ERROR_IF (ret, threads, "thread joined with error %s", ret); + thread->state = LUMIERA_THREADSTATE_JOINED; LUMIERA_CONDITION_SIGNAL; /* kiss it a last goodbye */ } diff --git a/src/lib/condition.c b/src/lib/condition.c index 97a0593d9..7c2d31d8e 100644 --- a/src/lib/condition.c +++ b/src/lib/condition.c @@ -35,10 +35,12 @@ lumiera_condition_init (LumieraCondition self, { if (self) { - pthread_cond_init (&self->cond, NULL); - pthread_mutex_init (&self->cndmutex, NULL); NOBUG_RESOURCE_HANDLE_INIT (self->rh); - NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "cond_var", purpose, self, self->rh, ctx); + NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "cond_var", purpose, self, self->rh, ctx) + { + pthread_mutex_init (&self->cndmutex, NULL); + pthread_cond_init (&self->cond, NULL); + } } return self; } @@ -51,13 +53,14 @@ lumiera_condition_destroy (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx); + NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx) + { + if (pthread_mutex_destroy (&self->cndmutex)) + LUMIERA_DIE (LOCK_DESTROY); - if (pthread_mutex_destroy (&self->cndmutex)) - LUMIERA_DIE (LOCK_DESTROY); - - if (pthread_cond_destroy (&self->cond)) - LUMIERA_DIE (LOCK_DESTROY); + if (pthread_cond_destroy (&self->cond)) + LUMIERA_DIE (LOCK_DESTROY); + } } return self; } diff --git a/src/lib/condition.h b/src/lib/condition.h index 752f23fd1..db06d5441 100644 --- a/src/lib/condition.h +++ b/src/lib/condition.h @@ -194,12 +194,13 @@ lumiera_condition_lock (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire condvar", *handle, ctx); + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire condvar", *handle, ctx) + { + if (pthread_mutex_lock (&self->cndmutex)) + LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - if (pthread_mutex_lock (&self->cndmutex)) - LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } } return self; @@ -214,19 +215,20 @@ lumiera_condition_trylock (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire condvar", *handle, ctx); - - int err = pthread_mutex_trylock (&self->cndmutex); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire condvar", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_trylock (&self->cndmutex); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -243,19 +245,20 @@ lumiera_condition_timedlock (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire condvar", *handle, ctx); - - int err = pthread_mutex_timedlock (&self->cndmutex, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire condvar", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_timedlock (&self->cndmutex, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -271,11 +274,12 @@ lumiera_condition_wait (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx); + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx) + { + pthread_cond_wait (&self->cond, &self->cndmutex); - pthread_cond_wait (&self->cond, &self->cndmutex); - - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } } return self; } @@ -290,19 +294,20 @@ lumiera_condition_timedwait (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx); - - int err; - do { - err = pthread_cond_timedwait (&self->cond, &self->cndmutex, timeout); - } while(err == EINTR); - - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - - if (err) + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx) { - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err; + do { + err = pthread_cond_timedwait (&self->cond, &self->cndmutex, timeout); + } while(err == EINTR); + + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + + if (err) + { + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } diff --git a/src/lib/error.c b/src/lib/error.c index 601b84e47..a7044ffb3 100644 --- a/src/lib/error.c +++ b/src/lib/error.c @@ -72,8 +72,7 @@ lumiera_error_tls_init (void) LumieraErrorcontext lumiera_error_get (void) { - if (lumiera_error_initialized == PTHREAD_ONCE_INIT) - pthread_once (&lumiera_error_initialized, lumiera_error_tls_init); + pthread_once (&lumiera_error_initialized, lumiera_error_tls_init); LumieraErrorcontext self = pthread_getspecific (lumiera_error_tls); if (!self) diff --git a/src/lib/mutex.c b/src/lib/mutex.c index eb1e0dc93..baaa39b07 100644 --- a/src/lib/mutex.c +++ b/src/lib/mutex.c @@ -34,9 +34,11 @@ lumiera_mutex_init (LumieraMutex self, { if (self) { - pthread_mutex_init (&self->mutex, NULL); NOBUG_RESOURCE_HANDLE_INIT (self->rh); - NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "mutex", purpose, self, self->rh, ctx); + NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "mutex", purpose, self, self->rh, ctx) + { + pthread_mutex_init (&self->mutex, NULL); + } } return self; } @@ -49,9 +51,11 @@ lumiera_mutex_destroy (LumieraMutex self, { if (self) { - NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx); - if (pthread_mutex_destroy (&self->mutex)) - LUMIERA_DIE (LOCK_DESTROY); + NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx) + { + if (pthread_mutex_destroy (&self->mutex)) + LUMIERA_DIE (LOCK_DESTROY); + } } return self; } diff --git a/src/lib/mutex.h b/src/lib/mutex.h index 2f60d46fd..ec9215e04 100644 --- a/src/lib/mutex.h +++ b/src/lib/mutex.h @@ -142,12 +142,13 @@ lumiera_mutex_lock (LumieraMutex self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire mutex", *handle, ctx); + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire mutex", *handle, ctx) + { + if (pthread_mutex_lock (&self->mutex)) + LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - if (pthread_mutex_lock (&self->mutex)) - LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } } return self; @@ -169,19 +170,20 @@ lumiera_mutex_trylock (LumieraMutex self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire mutex", *handle, ctx); - - int err = pthread_mutex_trylock (&self->mutex); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire mutex", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_trylock (&self->mutex); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -205,19 +207,20 @@ lumiera_mutex_timedlock (LumieraMutex self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire mutex", *handle, ctx); - - int err = pthread_mutex_timedlock (&self->mutex, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire mutex", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_timedlock (&self->mutex, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } diff --git a/src/lib/reccondition.c b/src/lib/reccondition.c index f31154a34..01feab0ee 100644 --- a/src/lib/reccondition.c +++ b/src/lib/reccondition.c @@ -46,13 +46,14 @@ lumiera_reccondition_init (LumieraReccondition self, { if (self) { - if (recursive_mutexattr_once == PTHREAD_ONCE_INIT) - pthread_once (&recursive_mutexattr_once, recursive_mutexattr_init); + pthread_once (&recursive_mutexattr_once, recursive_mutexattr_init); - pthread_cond_init (&self->cond, NULL); - pthread_mutex_init (&self->reccndmutex, &recursive_mutexattr); NOBUG_RESOURCE_HANDLE_INIT (self->rh); - NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "reccond_var", purpose, self, self->rh, ctx); + NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "reccond_var", purpose, self, self->rh, ctx) + { + pthread_mutex_init (&self->reccndmutex, &recursive_mutexattr); + pthread_cond_init (&self->cond, NULL); + } } return self; } @@ -65,13 +66,14 @@ lumiera_reccondition_destroy (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx); + NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx) + { + if (pthread_mutex_destroy (&self->reccndmutex)) + LUMIERA_DIE (LOCK_DESTROY); - if (pthread_mutex_destroy (&self->reccndmutex)) - LUMIERA_DIE (LOCK_DESTROY); - - if (pthread_cond_destroy (&self->cond)) - LUMIERA_DIE (LOCK_DESTROY); + if (pthread_cond_destroy (&self->cond)) + LUMIERA_DIE (LOCK_DESTROY); + } } return self; } diff --git a/src/lib/reccondition.h b/src/lib/reccondition.h index 99259712f..418d8556b 100644 --- a/src/lib/reccondition.h +++ b/src/lib/reccondition.h @@ -196,12 +196,12 @@ lumiera_reccondition_lock (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire reccondvar", *handle, ctx); - - if (pthread_mutex_lock (&self->reccndmutex)) - LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire reccondvar", *handle, ctx) + { + if (pthread_mutex_lock (&self->reccndmutex)) + LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } } return self; @@ -216,19 +216,20 @@ lumiera_reccondition_trylock (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire reccondvar", *handle, ctx); - - int err = pthread_mutex_trylock (&self->reccndmutex); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire reccondvar", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_trylock (&self->reccndmutex); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -245,19 +246,20 @@ lumiera_reccondition_timedlock (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire reccondvar", *handle, ctx); - - int err = pthread_mutex_timedlock (&self->reccndmutex, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire reccondvar", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_timedlock (&self->reccndmutex, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -273,11 +275,11 @@ lumiera_reccondition_wait (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx); - - pthread_cond_wait (&self->cond, &self->reccndmutex); - - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_RECURSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx) + { + pthread_cond_wait (&self->cond, &self->reccndmutex); + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } } return self; } @@ -292,19 +294,20 @@ lumiera_reccondition_timedwait (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx); - - int err; - do { - err = pthread_cond_timedwait (&self->cond, &self->reccndmutex, timeout); - } while(err == EINTR); - - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_RECURSIVE, *handle, ctx); - - if (err) + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx) { - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err; + do { + err = pthread_cond_timedwait (&self->cond, &self->reccndmutex, timeout); + } while(err == EINTR); + + if (!err) + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + else + { + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } diff --git a/src/lib/recmutex.c b/src/lib/recmutex.c index 7a852c2a1..ca3c2f37c 100644 --- a/src/lib/recmutex.c +++ b/src/lib/recmutex.c @@ -47,9 +47,11 @@ lumiera_recmutex_init (LumieraRecmutex self, { pthread_once (&recmutexattr_once, recmutexattr_init); - pthread_mutex_init (&self->recmutex, &recmutexattr); NOBUG_RESOURCE_HANDLE_INIT (self->rh); - NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "recmutex", purpose, self, self->rh, ctx); + NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "recmutex", purpose, self, self->rh, ctx) + { + pthread_mutex_init (&self->recmutex, &recmutexattr); + } } return self; @@ -63,9 +65,11 @@ lumiera_recmutex_destroy (LumieraRecmutex self, { if (self) { - NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx); - if (pthread_mutex_destroy (&self->recmutex)) - LUMIERA_DIE (LOCK_DESTROY); + NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx) + { + if (pthread_mutex_destroy (&self->recmutex)) + LUMIERA_DIE (LOCK_DESTROY); + } } return self; } diff --git a/src/lib/recmutex.h b/src/lib/recmutex.h index 8383e6210..18dff4acf 100644 --- a/src/lib/recmutex.h +++ b/src/lib/recmutex.h @@ -124,12 +124,13 @@ lumiera_recmutex_lock (LumieraRecmutex self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire mutex", *handle, ctx); + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire mutex", *handle, ctx) + { + if (pthread_mutex_lock (&self->recmutex)) + LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - if (pthread_mutex_lock (&self->recmutex)) - LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } } return self; @@ -144,19 +145,20 @@ lumiera_recmutex_trylock (LumieraRecmutex self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire mutex", *handle, ctx); - - int err = pthread_mutex_trylock (&self->recmutex); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire mutex", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_trylock (&self->recmutex); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -173,19 +175,20 @@ lumiera_recmutex_timedlock (LumieraRecmutex self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire mutex", *handle, ctx); - - int err = pthread_mutex_timedlock (&self->recmutex, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire mutex", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_timedlock (&self->recmutex, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } diff --git a/src/lib/resourcecollector.c b/src/lib/resourcecollector.c index 4ce58eaa0..84af12f86 100644 --- a/src/lib/resourcecollector.c +++ b/src/lib/resourcecollector.c @@ -74,8 +74,7 @@ lumiera_resourcecollector_run (enum lumiera_resource which, enum lumiera_resourc { TRACE (resourcecollector_dbg); - if (lumiera_resourcecollector_once == PTHREAD_ONCE_INIT) - pthread_once (&lumiera_resourcecollector_once, lumiera_resourcecollector_init_); + pthread_once (&lumiera_resourcecollector_once, lumiera_resourcecollector_init_); LUMIERA_MUTEX_SECTION (mutex_sync, &lumiera_resourcecollector_lock) { @@ -120,8 +119,7 @@ lumiera_resourcecollector_run (enum lumiera_resource which, enum lumiera_resourc LumieraResourcehandler lumiera_resourcecollector_register_handler (enum lumiera_resource resource, lumiera_resource_handler_fn handler, void* data) { - if (lumiera_resourcecollector_once == PTHREAD_ONCE_INIT) - pthread_once (&lumiera_resourcecollector_once, lumiera_resourcecollector_init_); + pthread_once (&lumiera_resourcecollector_once, lumiera_resourcecollector_init_); TRACE (resourcecollector_dbg); diff --git a/src/lib/rwlock.c b/src/lib/rwlock.c index 349af6dff..03d70b7e3 100644 --- a/src/lib/rwlock.c +++ b/src/lib/rwlock.c @@ -36,9 +36,11 @@ lumiera_rwlock_init (LumieraRWLock self, { if (self) { - pthread_rwlock_init (&self->rwlock, NULL); NOBUG_RESOURCE_HANDLE_INIT (self->rh); - NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "rwlock", purpose, self, self->rh, ctx); + NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "rwlock", purpose, self, self->rh, ctx) + { + pthread_rwlock_init (&self->rwlock, NULL); + } } return self; } @@ -51,9 +53,11 @@ lumiera_rwlock_destroy (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx); - if (pthread_rwlock_destroy (&self->rwlock)) - LUMIERA_DIE (LOCK_DESTROY); + NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx) + { + if (pthread_rwlock_destroy (&self->rwlock)) + LUMIERA_DIE (LOCK_DESTROY); + } } return self; } diff --git a/src/lib/rwlock.h b/src/lib/rwlock.h index f651f7b24..79b019660 100644 --- a/src/lib/rwlock.h +++ b/src/lib/rwlock.h @@ -170,19 +170,20 @@ lumiera_rwlock_rdlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire rwlock for reading", *handle, ctx); - - int err = pthread_rwlock_rdlock (&self->rwlock); - - if (!err) + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire rwlock for reading", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_rwlock_rdlock (&self->rwlock); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -198,19 +199,20 @@ lumiera_rwlock_tryrdlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire rwlock for reading", *handle, ctx); - - int err = pthread_rwlock_tryrdlock (&self->rwlock); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire rwlock for reading", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_rwlock_tryrdlock (&self->rwlock); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -227,19 +229,20 @@ lumiera_rwlock_timedrdlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire rwlock for reading", *handle, ctx); - - int err = pthread_rwlock_timedrdlock (&self->rwlock, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire rwlock for reading", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_rwlock_timedrdlock (&self->rwlock, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -255,12 +258,13 @@ lumiera_rwlock_wrlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire rwlock for writing", *handle, ctx); + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire rwlock for writing", *handle, ctx) + { + if (pthread_rwlock_wrlock (&self->rwlock)) + LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - if (pthread_rwlock_wrlock (&self->rwlock)) - LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } } return self; @@ -275,19 +279,20 @@ lumiera_rwlock_trywrlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire rwlock for writing", *handle, ctx); - - int err = pthread_rwlock_trywrlock (&self->rwlock); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire rwlock for writing", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_rwlock_trywrlock (&self->rwlock); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -304,19 +309,20 @@ lumiera_rwlock_timedwrlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire rwlock for writing", *handle, ctx); - - int err = pthread_rwlock_timedwrlock (&self->rwlock, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire rwlock for writing", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_rwlock_timedwrlock (&self->rwlock, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } diff --git a/src/lib/safeclib.c b/src/lib/safeclib.c index 73a0533ef..b6503a998 100644 --- a/src/lib/safeclib.c +++ b/src/lib/safeclib.c @@ -122,8 +122,7 @@ lumiera_tmpbuf_init (void) void lumiera_tmpbuf_freeall (void) { - if (lumiera_tmpbuf_tls_once == PTHREAD_ONCE_INIT) - pthread_once (&lumiera_tmpbuf_tls_once, lumiera_tmpbuf_init); + pthread_once (&lumiera_tmpbuf_tls_once, lumiera_tmpbuf_init); struct lumiera_tmpbuf_struct* buf = pthread_getspecific (lumiera_tmpbuf_tls_key); if (buf) @@ -139,8 +138,7 @@ lumiera_tmpbuf_freeall (void) void* lumiera_tmpbuf_provide (size_t size) { - if (lumiera_tmpbuf_tls_once == PTHREAD_ONCE_INIT) - pthread_once (&lumiera_tmpbuf_tls_once, lumiera_tmpbuf_init); + pthread_once (&lumiera_tmpbuf_tls_once, lumiera_tmpbuf_init); struct lumiera_tmpbuf_struct* buf = pthread_getspecific (lumiera_tmpbuf_tls_key); if (!buf) diff --git a/src/lib/test/test-helper.hpp b/src/lib/test/test-helper.hpp index afa79c743..5f1cc511c 100644 --- a/src/lib/test/test-helper.hpp +++ b/src/lib/test/test-helper.hpp @@ -129,15 +129,15 @@ namespace test{ * an assertion failure. In case of an exception, the #lumiera_error * state is checked, cleared and verified. */ -#define VERIFY_ERROR(ERROR_ID, ERRONEOUS_STATEMENT) \ - try \ - { \ - ERRONEOUS_STATEMENT ; \ - NOTREACHED(); \ - } \ - catch (...) \ - { \ - ASSERT (lumiera_error () == LUMIERA_ERROR_##ERROR_ID ); \ +#define VERIFY_ERROR(ERROR_ID, ERRONEOUS_STATEMENT) \ + try \ + { \ + ERRONEOUS_STATEMENT ; \ + NOTREACHED("'%s' resisted to fail", #ERRONEOUS_STATEMENT); \ + } \ + catch (...) \ + { \ + CHECK (lumiera_error_expect (LUMIERA_ERROR_##ERROR_ID)); \ } #endif diff --git a/tests/backend/test-threadpool.c b/tests/backend/test-threadpool.c index 5931d51a7..ede10b997 100644 --- a/tests/backend/test-threadpool.c +++ b/tests/backend/test-threadpool.c @@ -110,7 +110,7 @@ TEST ("threadpool1") LumieraThread t1 = lumiera_threadpool_acquire_thread(LUMIERA_THREADCLASS_INTERACTIVE, "test purpose", - &NOBUG_FLAG(test)); + &NOBUG_FLAG(TESTS)); // lumiera_threadpool_release_thread(t1); ECHO("acquired thread 1 %p",t1); lumiera_threadpool_destroy(); @@ -126,13 +126,13 @@ TEST ("two-thread-acquire") LumieraThread t1 = lumiera_threadpool_acquire_thread(LUMIERA_THREADCLASS_INTERACTIVE, "test purpose", - &NOBUG_FLAG(test)); + &NOBUG_FLAG(TESTS)); ECHO("acquiring thread 2"); LumieraThread t2 = lumiera_threadpool_acquire_thread(LUMIERA_THREADCLASS_IDLE, "test purpose", - &NOBUG_FLAG(test)); + &NOBUG_FLAG(TESTS)); ECHO("thread 1 state=%s", lumiera_threadstate_names[t1->state]); CHECK(LUMIERA_THREADSTATE_IDLE == t1->state); @@ -140,13 +140,13 @@ TEST ("two-thread-acquire") ECHO("thread 2 state=%s", lumiera_threadstate_names[t2->state]); CHECK(LUMIERA_THREADSTATE_IDLE == t2->state); - LUMIERA_CONDITION_SECTION(cond_sync, &t1->signal) + LUMIERA_CONDITION_SECTION(TESTS, &t1->signal) { t1->state = LUMIERA_THREADSTATE_WAKEUP; LUMIERA_CONDITION_SIGNAL; } - LUMIERA_CONDITION_SECTION(cond_sync, &t2->signal) + LUMIERA_CONDITION_SECTION(TESTS, &t2->signal) { t2->state = LUMIERA_THREADSTATE_WAKEUP; LUMIERA_CONDITION_SIGNAL; @@ -174,7 +174,7 @@ TEST ("many-sleepy-threads") &sleep_fn, (void *) &delay, "just sleep a bit", - &NOBUG_FLAG(test)); + &NOBUG_FLAG(TESTS)); } } @@ -199,7 +199,7 @@ TEST ("toomany-random-sleepy-threads (compiletest only)") &sleep_fn, (void *) &delay[i], "just sleep a bit", - &NOBUG_FLAG(test)); + &NOBUG_FLAG(TESTS)); } } lumiera_threadpool_destroy(); @@ -215,7 +215,7 @@ TEST ("no-function") NULL, NULL, "process my test function", - &NOBUG_FLAG(test)); + &NOBUG_FLAG(TESTS)); // cleanup ECHO("finished waiting"); @@ -236,7 +236,7 @@ TEST ("process-function") &is_prime, (void *)&number, //void * arg, "process my test function", - &NOBUG_FLAG(test)); // struct nobug_flag* flag) + &NOBUG_FLAG(TESTS)); // struct nobug_flag* flag) // cleanup lumiera_threadpool_destroy(); @@ -261,7 +261,7 @@ TEST ("many-random-sleepy-threads (compiletest only)") &sleep_fn, (void *) &delay[i], "just sleep a bit", - &NOBUG_FLAG(test)); + &NOBUG_FLAG(TESTS)); } } lumiera_threadpool_destroy(); @@ -277,7 +277,7 @@ TEST ("simple-sync") &other_fn, (void *)&value, "other thread", - &NOBUG_FLAG (test)); + &NOBUG_FLAG (TESTS)); ECHO ("syncing with the other thread"); lumiera_thread_sync_other (other); @@ -301,7 +301,7 @@ TEST ("sync-many") &sleeping_worker_fn, (void *)&value, "worker thread", - &NOBUG_FLAG (test)); + &NOBUG_FLAG (TESTS)); lumiera_thread_sync_other (threads[i]); } value += 42; diff --git a/tests/common/test-interfaces.c b/tests/common/test-interfaces.c index 217459851..61c680cac 100644 --- a/tests/common/test-interfaces.c +++ b/tests/common/test-interfaces.c @@ -170,7 +170,7 @@ LumieraInterface testacquire_one (LumieraInterface self, LumieraInterface interface) { (void) interface; - TRACE (tests, "Acquire one %s_%d_%s", self->interface, self->version, self->name); + TRACE (TESTS, "Acquire one %s_%d_%s", self->interface, self->version, self->name); one_keeps_two = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_two); one_keeps_three = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_three); return self; @@ -179,7 +179,7 @@ testacquire_one (LumieraInterface self, LumieraInterface interface) void testrelease_one (LumieraInterface self) { - TRACE (tests, "Release one %s_%d_%s", self->interface, self->version, self->name); + TRACE (TESTS, "Release one %s_%d_%s", self->interface, self->version, self->name); lumiera_interface_close ((LumieraInterface)one_keeps_two); lumiera_interface_close ((LumieraInterface)one_keeps_three); } @@ -191,7 +191,7 @@ LumieraInterface testacquire_two (LumieraInterface self, LumieraInterface interface) { (void) interface; - TRACE (tests, "Acquire two %s_%d_%s", self->interface, self->version, self->name); + TRACE (TESTS, "Acquire two %s_%d_%s", self->interface, self->version, self->name); two_keeps_one = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_one); two_keeps_four = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_four); return self; @@ -200,7 +200,7 @@ testacquire_two (LumieraInterface self, LumieraInterface interface) void testrelease_two (LumieraInterface self) { - TRACE (tests, "Release two %s_%d_%s", self->interface, self->version, self->name); + TRACE (TESTS, "Release two %s_%d_%s", self->interface, self->version, self->name); lumiera_interface_close ((LumieraInterface)two_keeps_one); lumiera_interface_close ((LumieraInterface)two_keeps_four); } @@ -212,7 +212,7 @@ LumieraInterface testacquire_three (LumieraInterface self, LumieraInterface interface) { (void) interface; - TRACE (tests, "Acquire three %s_%d_%s", self->interface, self->version, self->name); + TRACE (TESTS, "Acquire three %s_%d_%s", self->interface, self->version, self->name); three_keeps_two = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_two); three_keeps_four = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_four); return self; @@ -221,7 +221,7 @@ testacquire_three (LumieraInterface self, LumieraInterface interface) void testrelease_three (LumieraInterface self) { - TRACE (tests, "Release three %s_%d_%s", self->interface, self->version, self->name); + TRACE (TESTS, "Release three %s_%d_%s", self->interface, self->version, self->name); lumiera_interface_close ((LumieraInterface)three_keeps_two); lumiera_interface_close ((LumieraInterface)three_keeps_four); } @@ -234,7 +234,7 @@ LumieraInterface testacquire_four (LumieraInterface self, LumieraInterface interface) { (void) interface; - TRACE (tests, "Acquire four %s_%d_%s", self->interface, self->version, self->name); + TRACE (TESTS, "Acquire four %s_%d_%s", self->interface, self->version, self->name); four_keeps_one = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_one); four_keeps_two = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_two); four_keeps_three = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_three); @@ -244,7 +244,7 @@ testacquire_four (LumieraInterface self, LumieraInterface interface) void testrelease_four (LumieraInterface self) { - TRACE (tests, "Release four %s_%d_%s", self->interface, self->version, self->name); + TRACE (TESTS, "Release four %s_%d_%s", self->interface, self->version, self->name); lumiera_interface_close ((LumieraInterface)four_keeps_one); lumiera_interface_close ((LumieraInterface)four_keeps_two); lumiera_interface_close ((LumieraInterface)four_keeps_three); @@ -351,7 +351,7 @@ TEST ("dependencies_one") LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_one); ENSURE (handle); - TRACE (tests, "Sucessfully opened"); + TRACE (TESTS, "Sucessfully opened"); lumiera_interface_close ((LumieraInterface)handle); @@ -369,7 +369,7 @@ TEST ("dependencies_two") LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_two); ENSURE (handle); - TRACE (tests, "Sucessfully opened"); + TRACE (TESTS, "Sucessfully opened"); lumiera_interface_close ((LumieraInterface)handle); @@ -386,7 +386,7 @@ TEST ("dependencies_three") LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_three); ENSURE (handle); - TRACE (tests, "Sucessfully opened"); + TRACE (TESTS, "Sucessfully opened"); lumiera_interface_close ((LumieraInterface)handle); @@ -404,7 +404,7 @@ TEST ("dependencies_four") LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_four); ENSURE (handle); - TRACE (tests, "Sucessfully opened"); + TRACE (TESTS, "Sucessfully opened"); lumiera_interface_close ((LumieraInterface)handle); @@ -419,38 +419,38 @@ TEST ("dependencies_all") lumiera_interfaceregistry_init (); LUMIERA_INTERFACE_REGISTEREXPORTED; - TRACE (tests, "OPEN one"); + TRACE (TESTS, "OPEN one"); LUMIERA_INTERFACE_HANDLE(lumieraorg_testexample_void, 0) handle_one = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_one); ENSURE (handle_one); - TRACE (tests, "OPEN three"); + TRACE (TESTS, "OPEN three"); LUMIERA_INTERFACE_HANDLE(lumieraorg_testexample_void, 0) handle_three = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_three); ENSURE (handle_three); - TRACE (tests, "OPEN two"); + TRACE (TESTS, "OPEN two"); LUMIERA_INTERFACE_HANDLE(lumieraorg_testexample_void, 0) handle_two = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_two); ENSURE (handle_two); - TRACE (tests, "OPEN four"); + TRACE (TESTS, "OPEN four"); LUMIERA_INTERFACE_HANDLE(lumieraorg_testexample_void, 0) handle_four = LUMIERA_INTERFACE_OPEN (lumieraorg_testexample_void, 0, 0, lumieraorg_dependencytest_four); ENSURE (handle_four); - TRACE (tests, "Sucessfully OPENED"); + TRACE (TESTS, "Sucessfully OPENED"); - TRACE (tests, "CLOSE four"); + TRACE (TESTS, "CLOSE four"); lumiera_interface_close ((LumieraInterface)handle_four); - TRACE (tests, "CLOSE two"); + TRACE (TESTS, "CLOSE two"); lumiera_interface_close ((LumieraInterface)handle_two); - TRACE (tests, "CLOSE three"); + TRACE (TESTS, "CLOSE three"); lumiera_interface_close ((LumieraInterface)handle_three); - TRACE (tests, "CLOSE one"); + TRACE (TESTS, "CLOSE one"); lumiera_interface_close ((LumieraInterface)handle_one); diff --git a/tests/lib/subsystem-runner-test.cpp b/tests/lib/subsystem-runner-test.cpp index f5be9da3c..0787c40e1 100644 --- a/tests/lib/subsystem-runner-test.cpp +++ b/tests/lib/subsystem-runner-test.cpp @@ -401,10 +401,10 @@ namespace test { public: SubsystemRunner_test() - { lumiera_threadpool_init(); } + { } ~SubsystemRunner_test() - { lumiera_threadpool_destroy(); } + { } }; diff --git a/tests/lib/thread-wrapper-join-test.cpp b/tests/lib/thread-wrapper-join-test.cpp index 0237fb63e..4e817301c 100644 --- a/tests/lib/thread-wrapper-join-test.cpp +++ b/tests/lib/thread-wrapper-join-test.cpp @@ -75,7 +75,7 @@ namespace test { usleep (100000); // pause 100ms prior to modifying if (DESTRUCTION_CODE == secretValue) - lumiera_error_set(LUMIERA_ERROR_SPECIAL, 0); + LUMIERA_ERROR_SET(test, SPECIAL, 0); else aValue_ = secretValue+42; diff --git a/tests/lib/thread-wrapper-test.cpp b/tests/lib/thread-wrapper-test.cpp index b05a7d5c3..6b686b2dd 100644 --- a/tests/lib/thread-wrapper-test.cpp +++ b/tests/lib/thread-wrapper-test.cpp @@ -39,9 +39,11 @@ namespace backend { namespace { // private test classes and data... - ulong sum; + volatile ulong sum; ulong checksum; + Sync lockme; + const uint NUM_THREADS = 20; const uint MAX_RAND_SUMMAND = 100; @@ -55,8 +57,8 @@ namespace backend { struct TestThread - : Thread - , Sync // using dedicated locking for this test + : Sync // using dedicated locking for this test TODO: needs classlock + , Thread { TestThread() : Thread("test Thread creation", @@ -67,8 +69,13 @@ namespace backend { void theOperation (uint a, uint b) ///< the actual operation running in a separate thread { - Lock(this); - sum += (a+b); + //Lock(this); << broken we need a classlock, using sync-classlock is left as excercise for the reader + Sync::Lock gotit(&lockme); + sum *= 2; + usleep (200); // force preemption + sum += (2*(a+b)); + usleep (200); + sum /= 2; } }; diff --git a/tests/library/test-psplay.c b/tests/library/test-psplay.c index e7c201159..fbeede525 100644 --- a/tests/library/test-psplay.c +++ b/tests/library/test-psplay.c @@ -195,7 +195,7 @@ TEST ("basic_insert_dump") for (int i = 1; i <= end; ++i) { sprintf (key, "%d", i); - TRACE (tests, "insert %s", key); + TRACE (TESTS, "insert %s", key); psplay_insert (&splay_tree, (PSplaynode)testitem_new (key), 100); } @@ -205,14 +205,14 @@ TEST ("basic_insert_dump") for (int i = 1; i <= end; ++i) { sprintf (key, "%d", i); - TRACE (tests, "insert %s", key); + TRACE (TESTS, "insert %s", key); psplay_remove_key (&splay_tree, key); psplay_dump (&splay_tree, stderr); } for (int i = end; i; --i) { sprintf (key, "%d", i); - TRACE (tests, "insert %s", key); + TRACE (TESTS, "insert %s", key); psplay_remove_key (&splay_tree, key); psplay_dump (&splay_tree, stderr); } @@ -299,7 +299,7 @@ TEST ("basic_insert_splay") for (int i = 1; i <= end; ++i) { sprintf (key, "%d", i); - TRACE (tests, "insert %s", key); + TRACE (TESTS, "insert %s", key); psplay_insert (&splay_tree, (PSplaynode)testitem_new (key), 100); } diff --git a/tests/test.conf b/tests/test.conf index 662175123..38cf8082d 100755 --- a/tests/test.conf +++ b/tests/test.conf @@ -1 +1 @@ -LOGSUPPRESS='^\(\*\*[0-9]*\*\* \)\?[0-9]\{10,\}: \(TRACE\|INFO\|NOTICE\|WARNING\|ERR\|TODO\|PLANNED\|FIXME\|DEPRECATED\|UNIMPLEMENTED\|RESOURCE_ANNOUNCE\|RESOURCE_ENTER\|RESOURCE_STATE\|RESOURCE_LEAVE\):' +LOGSUPPRESS='^\(\*\*[0-9]*\*\* \)\?[0-9]\{10,\}[:!] \(TRACE\|INFO\|NOTICE\|WARNING\|ERR\|TODO\|PLANNED\|FIXME\|DEPRECATED\|UNIMPLEMENTED\|RESOURCE_ANNOUNCE\|RESOURCE_ENTER\|RESOURCE_STATE\|RESOURCE_LEAVE\):' diff --git a/tests/test.h b/tests/test.h index 987892956..01374701a 100644 --- a/tests/test.h +++ b/tests/test.h @@ -28,7 +28,7 @@ #include -NOBUG_DEFINE_FLAG (tests); +NOBUG_DEFINE_FLAG (TESTS); LUMIERA_ERROR_DEFINE (TEST, "test error"); #define TESTS_BEGIN \ @@ -36,7 +36,7 @@ int \ main (int argc, const char** argv) \ { \ NOBUG_INIT; \ - NOBUG_INIT_FLAG (tests); \ + NOBUG_INIT_FLAG (TESTS); \ \ if (argc == 1) \ { \ diff --git a/tests/test.sh b/tests/test.sh index 19df30e38..2b239ebed 100755 --- a/tests/test.sh +++ b/tests/test.sh @@ -1,6 +1,6 @@ #!/usr/bin/env bash -# Copyright (C) Lumiera.org -# 2007 - 2010, Christian Thaeter +# Copyright (C) Lumiera.org +# 2007, 2008, 2009, 2010, Christian Thaeter # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as @@ -59,7 +59,7 @@ LC_ALL=C #config validating the output the `LOGSUPRESS` variable can be set to a regex to filter this things out. #config The default as shown above filters some NoBug annotations and non fatal logging out. #config -LOGSUPPRESS='^\(\*\*[0-9]*\*\* \)\?[0-9]\{10,\}: \(TRACE\|INFO\|NOTICE\|WARNING\|ERR\):' +LOGSUPPRESS='^\(\*\*[0-9]*\*\* \)\?[0-9]\{10,\}[:!] \(TRACE\|INFO\|NOTICE\|WARNING\|ERR\):' #config PARA Resource Limits; ulimit; constrain resource limits #config It is possible to set some limits for tests to protect the system against really broken cases.