ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge remote branch 'ct/backend_devel' into second-tp-attempt

Browse source
This commit is contained in:
Michael Ploujnikov 2010-02-04 22:48:03 -05:00
commit c64984b859
30 changed files with 394 additions and 355 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
configure.ac
View file

@ -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)])
)

2
src/backend/file.c
View file

@ -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);
}

10
src/backend/filedescriptor.c
View file

@ -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);

38
src/backend/filehandlecache.c
View file

@ -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);
}
}
}

8
src/backend/filehandlecache.h
View file

@ -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

6
src/backend/thread-wrapper.hpp
View file

@ -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);
}
};

4
src/backend/threads.c
View file

@ -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 */
}

21
src/lib/condition.c
View file

@ -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;
}

95
src/lib/condition.h
View file

@ -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;
}
}
}

3
src/lib/error.c
View file

@ -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)

14
src/lib/mutex.c
View file

@ -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;
}

61
src/lib/mutex.h
View file

@ -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;
}
}
}

24
src/lib/reccondition.c
View file

@ -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;
}

97
src/lib/reccondition.h
View file

@ -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;
}
}
}

14
src/lib/recmutex.c
View file

@ -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;
}

61
src/lib/recmutex.h
View file

@ -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;
}
}
}

6
src/lib/resourcecollector.c
View file

@ -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);

14
src/lib/rwlock.c
View file

@ -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;
}

136
src/lib/rwlock.h
View file

@ -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;
}
}
}

6
src/lib/safeclib.c
View file

@ -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)

18
src/lib/test/test-helper.hpp
View file

@ -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

24
tests/backend/test-threadpool.c
View file

@ -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;

42
tests/common/test-interfaces.c
View file

@ -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);

4
tests/lib/subsystem-runner-test.cpp
View file

@ -401,10 +401,10 @@ namespace test {
public:
SubsystemRunner_test()
{ lumiera_threadpool_init(); }
{ }
~SubsystemRunner_test()
{ lumiera_threadpool_destroy(); }
{ }
};

2
tests/lib/thread-wrapper-join-test.cpp
View file

@ -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;

17
tests/lib/thread-wrapper-test.cpp
View file

@ -39,9 +39,11 @@ namespace backend {
namespace { // private test classes and data...
ulong sum;
volatile ulong sum;
ulong checksum;
Sync<NonrecursiveLock_NoWait> lockme;
const uint NUM_THREADS = 20;
const uint MAX_RAND_SUMMAND = 100;
@ -55,8 +57,8 @@ namespace backend {
struct TestThread
: Thread
, Sync<NonrecursiveLock_NoWait> // using dedicated locking for this test
: Sync<NonrecursiveLock_NoWait> // 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<NonrecursiveLock_NoWait>::Lock gotit(&lockme);
sum *= 2;
usleep (200); // force preemption
sum += (2*(a+b));
usleep (200);
sum /= 2;
}
};

8
tests/library/test-psplay.c
View file

@ -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);
}

2
tests/test.conf
View file

@ -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\):'

4
tests/test.h
View file

@ -28,7 +28,7 @@
#include <stdio.h>
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) \
{ \

6
tests/test.sh
View file

@ -1,6 +1,6 @@
#!/usr/bin/env bash
# Copyright (C) Lumiera.org
# 2007 - 2010, Christian Thaeter <ct@pipapo.org>
# Copyright (C) Lumiera.org
# 2007, 2008, 2009, 2010, Christian Thaeter <ct@pipapo.org>
#
# 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.