From 0a31c7d2db41f6a5e06a557da87ce55ef6dfaa22 Mon Sep 17 00:00:00 2001 From: Christian Thaeter Date: Sun, 2 Sep 2007 17:52:30 +0200 Subject: [PATCH 1/4] mutex implementation --- src/lib/mutex.c | 44 ++++++++++++ src/lib/mutex.h | 136 +++++++++++++++++++++++++++++++++++ tests/15locking.tests | 8 +++ tests/Makefile.am | 11 +-- tests/locking/condition.c | 49 +++++++++++++ tests/locking/mutex.c | 32 +++++++++ tests/locking/test-locking.c | 53 ++++++++++++++ 7 files changed, 329 insertions(+), 4 deletions(-) create mode 100644 src/lib/mutex.c create mode 100644 src/lib/mutex.h create mode 100644 tests/locking/condition.c create mode 100644 tests/locking/mutex.c create mode 100644 tests/locking/test-locking.c diff --git a/src/lib/mutex.c b/src/lib/mutex.c new file mode 100644 index 000000000..be36f58d2 --- /dev/null +++ b/src/lib/mutex.c @@ -0,0 +1,44 @@ +/* + mutex.c - mutex + + Copyright (C) CinelerraCV + 2007, 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 + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include "lib/mutex.h" + +CinelerraMutex +cinelerra_mutex_init (CinelerraMutex self) +{ + if (self) + { + pthread_mutex_init (&self->mutex, NULL); + } + return self; +} + +CinelerraMutex +cinelerra_mutex_destroy (CinelerraMutex self) +{ + if (self) + { + if (pthread_mutex_destroy (&self->mutex)) + CINELERRA_DIE; + } + return self; +} + diff --git a/src/lib/mutex.h b/src/lib/mutex.h new file mode 100644 index 000000000..d14f82c78 --- /dev/null +++ b/src/lib/mutex.h @@ -0,0 +1,136 @@ +/* + mutex.h - mutal exclusion locking + + Copyright (C) CinelerraCV + 2007, 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 + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#ifndef CINELERRA_MUTEX_H +#define CINELERRA_MUTEX_H + +#include "lib/locking.h" + +/** + * Mutex. + * + */ +struct cinelerra_mutex_struct +{ + pthread_mutex_t mutex; +}; +typedef struct cinelerra_mutex_struct cinelerra_mutex; +typedef cinelerra_mutex* CinelerraMutex; + + +/** + * Initialize a mutex variable + * @param self is a pointer to the mutex to be initialized + * @return self as given + */ +CinelerraMutex +cinelerra_mutex_init (CinelerraMutex self); + + +/** + * Destroy a mutex variable + * @param self is a pointer to the mutex to be destroyed + * @return self as given + */ +CinelerraMutex +cinelerra_mutex_destroy (CinelerraMutex self); + + + +/** + * mutexlock used to manage the state of a mutex variable. + */ +struct cinelerra_mutexlock_struct +{ + CinelerraMutex mutex; + enum cinelerra_lockstate state; +}; +typedef struct cinelerra_mutexlock_struct cinelerra_mutexlock; +typedef struct cinelerra_mutexlock_struct* CinelerraMutexlock; + +/* helper function for nobug */ +static inline void +cinelerra_mutexlock_ensureunlocked (CinelerraMutexlock self) +{ + ENSURE (self->state == CINELERRA_UNLOCKED, "forgot to unlock mutex"); +} + +/* override with a macro to use the cleanup checker */ +#define cinelerra_mutexlock \ +cinelerra_mutexlock NOBUG_CLEANUP(cinelerra_mutexlock_ensureunlocked) + + +/** + * initialize a mutexlock state + * @param self mutexlock to be initialized, must be an automatic variable + * @param mutex associated mutex + * @param state initial state of the mutex, either CINELERRA_LOCKED or CINELERRA_UNLOCKED + * @return self as given + * errors are fatal + */ +static inline CinelerraMutexlock +cinelerra_mutexlock_init (CinelerraMutexlock self, CinelerraMutex mutex, enum cinelerra_lockstate state) +{ + REQUIRE (self); + REQUIRE (mutex); + self->mutex = mutex; + self->state = state; + if (state == CINELERRA_LOCKED) + if (pthread_mutex_lock (&mutex->mutex)) + CINELERRA_DIE; + + return self; +} + +/** + * lock the mutex. + * must not already be locked + * @param self mutexlock associated with a mutex variable + */ +static inline void +cinelerra_mutexlock_lock (CinelerraMutexlock self) +{ + REQUIRE (self); + REQUIRE (self->state == CINELERRA_UNLOCKED, "mutex already locked"); + + if (pthread_mutex_lock (&self->mutex->mutex)) + CINELERRA_DIE; + + self->state = CINELERRA_LOCKED; +} + + +/** + * release mutex. + * a mutexlock must be unlocked before leaving scope + * @param self mutexlock associated with a mutex variable + */ +static inline int +cinelerra_mutexlock_unlock (CinelerraMutexlock self) +{ + REQUIRE (self); + REQUIRE (self->state == CINELERRA_LOCKED, "mutex was not locked"); + if (pthread_mutex_unlock (&self->mutex->mutex)) + CINELERRA_DIE; + self->state = CINELERRA_UNLOCKED; +} + +#endif diff --git a/tests/15locking.tests b/tests/15locking.tests index 1ef4938c5..7bea487d5 100644 --- a/tests/15locking.tests +++ b/tests/15locking.tests @@ -6,3 +6,11 @@ return: 134 END + + + +TEST "mutex not unlocked asserts" mutexforgotunlock < + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include "lib/condition.h" + +#if 0 +waiting_thread() +{ + lock; + wait; + unlock; +} + + +signaling_thread() +{ + signal(); +} +#endif + + +int +conditionforgotunlock () +{ + cinelerra_condition c; + cinelerra_condition_init (&c); + + cinelerra_conditionlock l; + cinelerra_conditionlock_init (&l, &c, CINELERRA_LOCKED); + return 0; +} diff --git a/tests/locking/mutex.c b/tests/locking/mutex.c new file mode 100644 index 000000000..3a1ff964f --- /dev/null +++ b/tests/locking/mutex.c @@ -0,0 +1,32 @@ +/* + test mutex functions + + Copyright (C) CinelerraCV + 2007, 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 + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include "lib/mutex.h" + +int mutexforgotunlock() +{ + cinelerra_mutex m; + cinelerra_mutex_init (&m); + + cinelerra_mutexlock l; + cinelerra_mutexlock_init (&l, &m, CINELERRA_LOCKED); + return 0; +} diff --git a/tests/locking/test-locking.c b/tests/locking/test-locking.c new file mode 100644 index 000000000..78bc99779 --- /dev/null +++ b/tests/locking/test-locking.c @@ -0,0 +1,53 @@ +/* + test-locking.c - test locking functions + + Copyright (C) CinelerraCV + 2007, 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 + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include +#include + +#include "lib/error.h" + +CINELERRA_ERROR_DEFINE(TEST, "test error"); + +int conditionforgotunlock (); +int mutexforgotunlock (); + + +int +main (int argc, char** argv) +{ + NOBUG_INIT; + + if (argc == 1) + return 0; + + if (!strcmp(argv[1], "conditionforgotunlock")) + { + return conditionforgotunlock (); + } + if (!strcmp(argv[1], "mutexforgotunlock")) + { + return mutexforgotunlock (); + } + else + return 1; + + return 0; +} From 04f9424ad89517e4d064d95e1ebd40bb7a68f72d Mon Sep 17 00:00:00 2001 From: Christian Thaeter Date: Sun, 2 Sep 2007 23:25:38 +0200 Subject: [PATCH 2/4] forgotten to commit the Makefile.am with the last commit --- src/lib/Makefile.am | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am index 320a579c2..42524b322 100644 --- a/src/lib/Makefile.am +++ b/src/lib/Makefile.am @@ -26,6 +26,7 @@ libcin3_a_SOURCES = \ $(libcin3_a_srcdir)/error.c \ $(libcin3_a_srcdir)/time.c \ $(libcin3_a_srcdir)/framerate.c \ + $(libcin3_a_srcdir)/mutex.c \ $(libcin3_a_srcdir)/condition.c @@ -35,5 +36,6 @@ noinst_HEADERS += \ $(libcin3_a_srcdir)/time.h \ $(libcin3_a_srcdir)/framerate.h \ $(libcin3_a_srcdir)/locking.h \ + $(libcin3_a_srcdir)/mutex.h \ $(libcin3_a_srcdir)/condition.h From d508f7cb7a3267640f43bc44a938ee0200626525 Mon Sep 17 00:00:00 2001 From: Christian Thaeter Date: Mon, 3 Sep 2007 06:35:13 +0200 Subject: [PATCH 3/4] rwlock first implementation --- src/lib/Makefile.am | 2 + src/lib/locking.h | 4 +- src/lib/rwlock.c | 142 ++++++++++++++++++++++++++++++++++++++++++++ src/lib/rwlock.h | 139 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 285 insertions(+), 2 deletions(-) create mode 100644 src/lib/rwlock.c create mode 100644 src/lib/rwlock.h diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am index 42524b322..46ae62363 100644 --- a/src/lib/Makefile.am +++ b/src/lib/Makefile.am @@ -27,6 +27,7 @@ libcin3_a_SOURCES = \ $(libcin3_a_srcdir)/time.c \ $(libcin3_a_srcdir)/framerate.c \ $(libcin3_a_srcdir)/mutex.c \ + $(libcin3_a_srcdir)/rwlock.c \ $(libcin3_a_srcdir)/condition.c @@ -37,5 +38,6 @@ noinst_HEADERS += \ $(libcin3_a_srcdir)/framerate.h \ $(libcin3_a_srcdir)/locking.h \ $(libcin3_a_srcdir)/mutex.h \ + $(libcin3_a_srcdir)/rwlock.h \ $(libcin3_a_srcdir)/condition.h diff --git a/src/lib/locking.h b/src/lib/locking.h index aa722a568..5c6549f31 100644 --- a/src/lib/locking.h +++ b/src/lib/locking.h @@ -36,8 +36,8 @@ enum cinelerra_lockstate { CINELERRA_UNLOCKED, CINELERRA_LOCKED, - CINELERRA_RLOCKED, - CINELERRA_WLOCKED + CINELERRA_RDLOCKED, + CINELERRA_WRLOCKED }; #endif diff --git a/src/lib/rwlock.c b/src/lib/rwlock.c new file mode 100644 index 000000000..018c69f63 --- /dev/null +++ b/src/lib/rwlock.c @@ -0,0 +1,142 @@ +/* + rwlock.c - read/write locks + + Copyright (C) CinelerraCV + 2007, 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 + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ +#define _GNU_SOURCE + +#include +#include "lib/rwlock.h" + +CINELERRA_ERROR_DEFINE(RWLOCK_AGAIN, "maximum number of readlocks exceed"); +CINELERRA_ERROR_DEFINE(RWLOCK_DEADLOCK, "deadlock detected"); + + +CinelerraRWLock +cinelerra_rwlock_init (CinelerraRWLock self) +{ + if (self) + { + pthread_rwlock_init (&self->rwlock, NULL); + } + return self; +} + +CinelerraRWLock +cinelerra_rwlock_destroy (CinelerraRWLock self) +{ + if (self) + { + if (pthread_rwlock_destroy (&self->rwlock)) + CINELERRA_DIE; + } + return self; +} + + + + +CinelerraRWLockacquirer +cinelerra_rwlockacquirer_init (CinelerraRWLockacquirer self, CinelerraRWLock rwlock, enum cinelerra_lockstate state) +{ + REQUIRE (self); + REQUIRE (rwlock); + REQUIRE (state != CINELERRA_LOCKED, "illegal state for rwlock"); + self->rwlock = rwlock; + self->state = state; + + switch (state) + { + case CINELERRA_RDLOCKED: + switch (pthread_rwlock_rdlock (&rwlock->rwlock)) + { + case 0: + break; + case EAGAIN: + cinelerra_error_set (CINELERRA_ERROR_RWLOCK_AGAIN); + return NULL; + case EDEADLK: + cinelerra_error_set (CINELERRA_ERROR_RWLOCK_DEADLOCK); + return NULL; + default: + CINELERRA_DIE; + } + case CINELERRA_WRLOCKED: + switch (pthread_rwlock_wrlock (&rwlock->rwlock)) + { + case 0: + break; + case EDEADLK: + cinelerra_error_set (CINELERRA_ERROR_RWLOCK_DEADLOCK); + return NULL; + default: + CINELERRA_DIE; + } + default: + break; + } + return self; +} + + +CinelerraRWLockacquirer +cinelerra_rwlockacquirer_rdlock (CinelerraRWLockacquirer self) +{ + REQUIRE (self); + REQUIRE (self->state == CINELERRA_UNLOCKED, "rwlock already locked"); + + switch (pthread_rwlock_rdlock (&self->rwlock->rwlock)) + { + case 0: + break; + case EAGAIN: + cinelerra_error_set (CINELERRA_ERROR_RWLOCK_AGAIN); + return NULL; + case EDEADLK: + cinelerra_error_set (CINELERRA_ERROR_RWLOCK_DEADLOCK); + return NULL; + default: + CINELERRA_DIE; + } + + self->state = CINELERRA_RDLOCKED; + return self; +} + + +CinelerraRWLockacquirer +cinelerra_rwlockacquirer_wrlock (CinelerraRWLockacquirer self) +{ + REQUIRE (self); + REQUIRE (self->state == CINELERRA_UNLOCKED, "rwlock already locked"); + + switch (pthread_rwlock_wrlock (&self->rwlock->rwlock)) + { + case 0: + break; + case EDEADLK: + cinelerra_error_set (CINELERRA_ERROR_RWLOCK_DEADLOCK); + return NULL; + default: + CINELERRA_DIE; + } + + self->state = CINELERRA_WRLOCKED; + return self; +} + diff --git a/src/lib/rwlock.h b/src/lib/rwlock.h new file mode 100644 index 000000000..9bc07f9f3 --- /dev/null +++ b/src/lib/rwlock.h @@ -0,0 +1,139 @@ +/* + rwlock.h - read/write locks + + Copyright (C) CinelerraCV + 2007, 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 + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#ifndef CINELERRA_RWLOCK_H +#define CINELERRA_RWLOCK_H + +#ifndef _GNU_SOURCE +#error "This header must be included with _GNU_SOURCE or _POSIX_C_SOURCE >= 200112L defined" +#endif + +#include +#include + +#include "lib/locking.h" + +CINELERRA_ERROR_DECLARE(RWLOCK_AGAIN); +CINELERRA_ERROR_DECLARE(RWLOCK_DEADLOCK); + + +/** + * RWLock. + * + */ +struct cinelerra_rwlock_struct +{ + pthread_rwlock_t rwlock; +}; +typedef struct cinelerra_rwlock_struct cinelerra_rwlock; +typedef cinelerra_rwlock* CinelerraRWLock; + + +/** + * Initialize a rwlock + * @param self is a pointer to the rwlock to be initialized + * @return self as given + */ +CinelerraRWLock +cinelerra_rwlock_init (CinelerraRWLock self); + + +/** + * destroy a rwlock + * @param self is a pointer to the rwlock to be initialized + * @return self on success or NULL at error + */ +CinelerraRWLock +cinelerra_rwlock_destroy (CinelerraRWLock self); + + + + +/** + * rwlockacquirer used to manage the state of a rwlock variable. + */ +struct cinelerra_rwlockacquirer_struct +{ + CinelerraRWLock rwlock; + enum cinelerra_lockstate state; +}; +typedef struct cinelerra_rwlockacquirer_struct cinelerra_rwlockacquirer; +typedef struct cinelerra_rwlockacquirer_struct* CinelerraRWLockacquirer; + +/* helper function for nobug */ +static inline void +cinelerra_rwlockacquirer_ensureunlocked (CinelerraRWLockacquirer self) +{ + ENSURE (self->state == CINELERRA_UNLOCKED, "forgot to unlock the rwlock mutex"); +} + +/* override with a macro to use the cleanup checker */ +#define cinelerra_rwlockacquirer \ +cinelerra_rwlockacquirer NOBUG_CLEANUP(cinelerra_rwlockacquirer_ensureunlocked) + + +/** + * initialize a rwlockacquirer state + * @param self rwlockacquirer to be initialized, must be an automatic variable + * @param cond associated rwlock + * @param state initial state of the mutex, either CINELERRA_RDLOCKED, CINELERRA_WRLOCKED or CINELERRA_UNLOCKED + * @return self as given or NULL on error + */ +CinelerraRWLockacquirer +cinelerra_rwlockacquirer_init (CinelerraRWLockacquirer self, CinelerraRWLock rwlock, enum cinelerra_lockstate state); + +/** + * readlock the rwlock. + * must not already be locked + * @param self rwlockacquirer associated with a rwlock + * @return self as given or NULL on error + */ +CinelerraRWLockacquirer +cinelerra_rwlockacquirer_rdlock (CinelerraRWLockacquirer self); + + +/** + * writelock the rwlock. + * must not already be locked + * @param self rwlockacquirer associated with a rwlock + * @return self as given or NULL on error + */ +CinelerraRWLockacquirer +cinelerra_rwlockacquirer_wrlock (CinelerraRWLockacquirer self); + + +/** + * release rwlock. + * a rwlockacquirer must be unlocked before leaving scope + * @param self rwlockacquirer associated with a rwlock variable + */ +static inline void +cinelerra_rwlockacquirer_unlock (CinelerraRWLockacquirer self) +{ + REQUIRE (self); + REQUIRE (self->state != CINELERRA_UNLOCKED, "rwlock was not locked"); + if (pthread_rwlock_unlock (&self->rwlock->rwlock)) + CINELERRA_DIE; + self->state = CINELERRA_UNLOCKED; +} + + +#endif From f1aba12af80e589029bb0bd15f68a188fbaafec1 Mon Sep 17 00:00:00 2001 From: Christian Thaeter Date: Mon, 3 Sep 2007 06:40:44 +0200 Subject: [PATCH 4/4] renamed *lock to *acquirer --- src/lib/condition.h | 44 +++++++++++++++++++-------------------- src/lib/mutex.h | 32 ++++++++++++++-------------- tests/locking/condition.c | 4 ++-- tests/locking/mutex.c | 4 ++-- 4 files changed, 42 insertions(+), 42 deletions(-) diff --git a/src/lib/condition.h b/src/lib/condition.h index e55c8ed0b..a34ce45ff 100644 --- a/src/lib/condition.h +++ b/src/lib/condition.h @@ -91,38 +91,38 @@ cinelerra_condition_broadcast (CinelerraCondition self) /** - * conditionlock used to manage the state of a condition variable. + * conditionacquirer used to manage the state of a condition variable. */ -struct cinelerra_conditionlock_struct +struct cinelerra_conditionacquirer_struct { CinelerraCondition cond; enum cinelerra_lockstate state; }; -typedef struct cinelerra_conditionlock_struct cinelerra_conditionlock; -typedef struct cinelerra_conditionlock_struct* CinelerraConditionlock; +typedef struct cinelerra_conditionacquirer_struct cinelerra_conditionacquirer; +typedef struct cinelerra_conditionacquirer_struct* CinelerraConditionacquirer; /* helper function for nobug */ static inline void -cinelerra_conditionlock_ensureunlocked (CinelerraConditionlock self) +cinelerra_conditionacquirer_ensureunlocked (CinelerraConditionacquirer self) { ENSURE (self->state == CINELERRA_UNLOCKED, "forgot to unlock the condition mutex"); } /* override with a macro to use the cleanup checker */ -#define cinelerra_conditionlock \ -cinelerra_conditionlock NOBUG_CLEANUP(cinelerra_conditionlock_ensureunlocked) +#define cinelerra_conditionacquirer \ +cinelerra_conditionacquirer NOBUG_CLEANUP(cinelerra_conditionacquirer_ensureunlocked) /** - * initialize a conditionlock state - * @param self conditionlock to be initialized, must be an automatic variable + * initialize a conditionacquirer state + * @param self conditionacquirer to be initialized, must be an automatic variable * @param cond associated condition variable * @param state initial state of the mutex, either CINELERRA_LOCKED or CINELERRA_UNLOCKED * @return self as given * errors are fatal */ -static inline CinelerraConditionlock -cinelerra_conditionlock_init (CinelerraConditionlock self, CinelerraCondition cond, enum cinelerra_lockstate state) +static inline CinelerraConditionacquirer +cinelerra_conditionacquirer_init (CinelerraConditionacquirer self, CinelerraCondition cond, enum cinelerra_lockstate state) { REQUIRE (self); REQUIRE (cond); @@ -138,10 +138,10 @@ cinelerra_conditionlock_init (CinelerraConditionlock self, CinelerraCondition co /** * lock the mutex. * must not already be locked - * @param self conditionlock associated with a condition variable + * @param self conditionacquirer associated with a condition variable */ static inline void -cinelerra_conditionlock_lock (CinelerraConditionlock self) +cinelerra_conditionacquirer_lock (CinelerraConditionacquirer self) { REQUIRE (self); REQUIRE (self->state == CINELERRA_UNLOCKED, "mutex already locked"); @@ -156,10 +156,10 @@ cinelerra_conditionlock_lock (CinelerraConditionlock self) /** * wait on a locked condition. * Waits until the condition variable gets signaled from another thread. Must already be locked. - * @param self conditionlock associated with a condition variable + * @param self conditionacquirer associated with a condition variable */ static inline void -cinelerra_conditionlock_wait (CinelerraConditionlock self) +cinelerra_conditionacquirer_wait (CinelerraConditionacquirer self) { REQUIRE (self); REQUIRE (self->state == CINELERRA_LOCKED, "mutex must be locked"); @@ -169,11 +169,11 @@ cinelerra_conditionlock_wait (CinelerraConditionlock self) /** * release mutex. - * a conditionlock must be unlocked before leaving scope - * @param self conditionlock associated with a condition variable + * a conditionacquirer must be unlocked before leaving scope + * @param self conditionacquirer associated with a condition variable */ static inline int -cinelerra_conditionlock_unlock (CinelerraConditionlock self) +cinelerra_conditionacquirer_unlock (CinelerraConditionacquirer self) { REQUIRE (self); REQUIRE (self->state == CINELERRA_LOCKED, "mutex was not locked"); @@ -185,10 +185,10 @@ cinelerra_conditionlock_unlock (CinelerraConditionlock self) /** * signal a single waiting thread - * @param self conditionlock associated with the condition variable to be signaled + * @param self conditionacquirer associated with the condition variable to be signaled */ static inline void -cinelerra_conditionlock_signal (CinelerraConditionlock self) +cinelerra_conditionacquirer_signal (CinelerraConditionacquirer self) { REQUIRE (self); REQUIRE (self->state == CINELERRA_LOCKED, "mutex was not locked"); @@ -198,10 +198,10 @@ cinelerra_conditionlock_signal (CinelerraConditionlock self) /** * signal all waiting threads - * @param self conditionlock associated with the condition variable to be signaled + * @param self conditionacquirer associated with the condition variable to be signaled */ static inline int -cinelerra_conditionlock_broadcast (CinelerraConditionlock self) +cinelerra_conditionacquirer_broadcast (CinelerraConditionacquirer self) { REQUIRE (self); REQUIRE (self->state == CINELERRA_LOCKED, "mutex was not locked"); diff --git a/src/lib/mutex.h b/src/lib/mutex.h index d14f82c78..3110e399d 100644 --- a/src/lib/mutex.h +++ b/src/lib/mutex.h @@ -56,38 +56,38 @@ cinelerra_mutex_destroy (CinelerraMutex self); /** - * mutexlock used to manage the state of a mutex variable. + * mutexacquirer used to manage the state of a mutex variable. */ -struct cinelerra_mutexlock_struct +struct cinelerra_mutexacquirer_struct { CinelerraMutex mutex; enum cinelerra_lockstate state; }; -typedef struct cinelerra_mutexlock_struct cinelerra_mutexlock; -typedef struct cinelerra_mutexlock_struct* CinelerraMutexlock; +typedef struct cinelerra_mutexacquirer_struct cinelerra_mutexacquirer; +typedef struct cinelerra_mutexacquirer_struct* CinelerraMutexacquirer; /* helper function for nobug */ static inline void -cinelerra_mutexlock_ensureunlocked (CinelerraMutexlock self) +cinelerra_mutexacquirer_ensureunlocked (CinelerraMutexacquirer self) { ENSURE (self->state == CINELERRA_UNLOCKED, "forgot to unlock mutex"); } /* override with a macro to use the cleanup checker */ -#define cinelerra_mutexlock \ -cinelerra_mutexlock NOBUG_CLEANUP(cinelerra_mutexlock_ensureunlocked) +#define cinelerra_mutexacquirer \ +cinelerra_mutexacquirer NOBUG_CLEANUP(cinelerra_mutexacquirer_ensureunlocked) /** - * initialize a mutexlock state - * @param self mutexlock to be initialized, must be an automatic variable + * initialize a mutexacquirer state + * @param self mutexacquirer to be initialized, must be an automatic variable * @param mutex associated mutex * @param state initial state of the mutex, either CINELERRA_LOCKED or CINELERRA_UNLOCKED * @return self as given * errors are fatal */ -static inline CinelerraMutexlock -cinelerra_mutexlock_init (CinelerraMutexlock self, CinelerraMutex mutex, enum cinelerra_lockstate state) +static inline CinelerraMutexacquirer +cinelerra_mutexacquirer_init (CinelerraMutexacquirer self, CinelerraMutex mutex, enum cinelerra_lockstate state) { REQUIRE (self); REQUIRE (mutex); @@ -103,10 +103,10 @@ cinelerra_mutexlock_init (CinelerraMutexlock self, CinelerraMutex mutex, enum ci /** * lock the mutex. * must not already be locked - * @param self mutexlock associated with a mutex variable + * @param self mutexacquirer associated with a mutex variable */ static inline void -cinelerra_mutexlock_lock (CinelerraMutexlock self) +cinelerra_mutexacquirer_lock (CinelerraMutexacquirer self) { REQUIRE (self); REQUIRE (self->state == CINELERRA_UNLOCKED, "mutex already locked"); @@ -120,11 +120,11 @@ cinelerra_mutexlock_lock (CinelerraMutexlock self) /** * release mutex. - * a mutexlock must be unlocked before leaving scope - * @param self mutexlock associated with a mutex variable + * a mutexacquirer must be unlocked before leaving scope + * @param self mutexacquirer associated with a mutex variable */ static inline int -cinelerra_mutexlock_unlock (CinelerraMutexlock self) +cinelerra_mutexacquirer_unlock (CinelerraMutexacquirer self) { REQUIRE (self); REQUIRE (self->state == CINELERRA_LOCKED, "mutex was not locked"); diff --git a/tests/locking/condition.c b/tests/locking/condition.c index 2b4e69518..72b56285c 100644 --- a/tests/locking/condition.c +++ b/tests/locking/condition.c @@ -43,7 +43,7 @@ conditionforgotunlock () cinelerra_condition c; cinelerra_condition_init (&c); - cinelerra_conditionlock l; - cinelerra_conditionlock_init (&l, &c, CINELERRA_LOCKED); + cinelerra_conditionacquirer l; + cinelerra_conditionacquirer_init (&l, &c, CINELERRA_LOCKED); return 0; } diff --git a/tests/locking/mutex.c b/tests/locking/mutex.c index 3a1ff964f..af4b563d9 100644 --- a/tests/locking/mutex.c +++ b/tests/locking/mutex.c @@ -26,7 +26,7 @@ int mutexforgotunlock() cinelerra_mutex m; cinelerra_mutex_init (&m); - cinelerra_mutexlock l; - cinelerra_mutexlock_init (&l, &m, CINELERRA_LOCKED); + cinelerra_mutexacquirer l; + cinelerra_mutexacquirer_init (&l, &m, CINELERRA_LOCKED); return 0; }