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

sync with new backend code

Browse source 
Merge commit 'pipapo/library'
This commit is contained in:
Fischlurch 2007-09-12 07:15:20 +02:00
commit 0950616b21
15 changed files with 1413 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/lib/Makefile.am
View file

@ -26,6 +26,8 @@ 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)/rwlock.c \
$(libcin3_a_srcdir)/condition.c
@ -35,5 +37,7 @@ 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)/rwlock.h \
$(libcin3_a_srcdir)/condition.h

44
src/lib/condition.h
View file

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

517
src/lib/llist.h Normal file
View file

@ -0,0 +1,517 @@
/*
llist.h - simple intrusive cyclic double linked list
Copyright (C)
2003, 2005 Christian Thaeter <chth@gmx.net>
Copyright (C) CinelerraCV
2007, 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
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 LLIST_H
#define LLIST_H
#include <stddef.h>
/**
* @file Intrusive cyclic double linked list
* There is only one node type which contains a forward and a backward pointer. In a empty initialized node,
* this pointers point to the node itself. Note that these pointers can never ever become NULL.
* This lists are used by using one node as 'root' node where its both pointers are the head/tail pointer to the actual list.
* Care needs to be taken to ensure not to apply any operations meant to be applied to data nodes to the root node.
* This way is the prefered way to use this lists.
* Alternatively one can store only a chain of data nodes and use a LList pointer to point to the first item
* (which might be NULL in case no data is stored). When using the 2nd approach care must be taken since most functions
* below expect lists to have a root node.
*
* This header can be used in 2 different ways:
* 1) (prerefered) just including it provides all functions as static inlined functions. This is the default
* 2) #define LLIST_INTERFACE before including this header gives only the declarations
* #define LLIST_IMPLEMENTATION before including this header yields in definitions
* this can be used to generate a library. This is currently untested and not recommended.
* The rationale for using inlined functions is that most functions are very small and likely to be used in performance critical parts.
* Inlining can give a hughe performance and optimization improvement here.
* The few functions which are slightly larger are expected to be the less common used ones, so inlining them too shouldn't be a problem either
*/
/* TODO __STDC_VERSION__ 199901L
150) This macro was not specified in ISO/IEC 9899:1990 and was specified as 199409L in
ISO/IEC 9899/AMD1:1995. The intention is that this will remain an integer constant of type long
int that is increased with each revision of this International Standard.
*/
#ifdef HAVE_INLINE
# define LLIST_MACRO static inline
#else
# ifdef __GNUC__
# define LLIST_MACRO static __inline__
# else
# define LLIST_MACRO static
# endif
#endif
#if defined(LLIST_INTERFACE)
/* only the interface is generated */
#define LLIST_FUNC(proto, ...) proto
#elif defined(LLIST_IMPLEMENTATION)
/* generate a non inlined implementation */
#define LLIST_FUNC(proto, ...) proto { __VA_ARGS__ }
#else
/* all functions are macro-like inlined */
#define LLIST_FUNC(proto, ...) LLIST_MACRO proto { __VA_ARGS__ }
#endif
/*
* Type of a llist node.
*/
struct llist_struct
{
struct llist_struct *next;
struct llist_struct *prev;
};
typedef struct llist_struct llist;
typedef llist * LList;
typedef const llist * const_LList;
typedef llist ** LList_ref;
/**
* Macro to instantiate a local llist.
* @param name of the llist node
*/
#define LLIST_AUTO(name) llist name = {&name,&name}
/**
* cast back from a member of a structure to a pointer of the structure
*/
/* example:
struct foo
{
int bar;
llist l;
} x;
LLIST_TO_STRUCTP (&x.l, foo, l)->bar
*/
#define LLIST_TO_STRUCTP(llist, type, member) \
((type*)(((char*)(llist)) - offsetof(type, member)))
/**
* Iterate forward over a list.
* @param list the root node of the list to be iterated
* @param node pointer to the iterated node
*/
#define LLIST_FOREACH(list, node) \
if (!list); else \
for (LList node = llist_head (list); \
! llist_is_end (node, list); \
llist_forward (&node))
/**
* Iterate backward over a list.
* @param list the root node of the list to be iterated
* @param node pointer to the iterated node
*/
#define LLIST_FOREACH_REV(list, node) \
if (!list); else \
for (LList node = llist_tail (list); \
! llist_is_end (node, list); \
llist_backward (&node))
/**
* Consume a list from head.
* The body of this statement should remove the head from the list, else it would be a infinite loop
* @param list the root node of the list to be consumed
* @param head pointer to the head node
*/
#define LLIST_WHILE_HEAD(list, head) \
if (!list); else \
for (LList head = llist_head (list); \
!llist_is_empty (list); \
head = llist_head (list))
/**
* Consume a list from tail.
* The body of this statement should remove the tail from the list, else it would be a infinite loop
* @param list the root node of the list to be consumed
* @param tail pointer to the tail node
*/
#define LLIST_WHILE_TAIL(list, tail) \
if (!list); else \
for (LList tail = llist_tail (list); \
!llist_is_empty (list); \
tail = llist_tail (list))
/**
* Initialize a new llist.
* Must not be applied to a list node which is not empty! Lists need to be initialized
* before any other operation on them is called.
* @param self node to be initialized
*/
LLIST_FUNC (void llist_init (LList self),
self->next = self->prev = self;
);
/**
* Check if a node is not linked with some other node.
*/
LLIST_FUNC (int llist_is_empty (const_LList self),
return self->next == self;
);
/**
* Check if self is the only node in a list or self is not in a list.
* @param self node to be checked
*/
LLIST_FUNC (int llist_is_single (const_LList self),
return self->next->next == self;
);
/**
* Check for the head of a list.
* @param self root of the list
* @param head expected head of the list
*/
LLIST_FUNC (int llist_is_head (const_LList self, const_LList head),
return self->next == head;
);
/**
* Check for the tail of a list.
* @param self root of the list
* @param tail expected tail of the list
*/
LLIST_FUNC (int llist_is_tail (const_LList self, const_LList tail),
return self->prev == tail;
);
/**
* Check for the end of a list.
* The end is by definition one past the tail of a list, which is the root node itself.
* @param self root node of the list
* @param end expected end of the list
*/
LLIST_FUNC (int llist_is_end (const_LList self, const_LList end),
return self == end;
);
/**
* Check if a node is a member of a list.
* @param self root node of the list
* @param member node to be searched
*/
LLIST_FUNC (int llist_is_member (const_LList self, const_LList member),
for (const_LList i = member->next; i != member; i = i->next)
{
if (i == self)
return 1;
}
return 0;
);
/**
* Check the order of elements in a list.
* @param self root node of the list
* @param before expected to be before after
* @param after expected to be after before
*/
LLIST_FUNC (int llist_is_before_after (const_LList self, const_LList before, const_LList after),
for (const_LList i = before->next; i != self; i = i->next)
{
if (i == after)
return 1;
}
return 0;
);
/**
* Count the nodes of a list.
* @param self root node of the list
* @return number of nodes in self
*/
LLIST_FUNC (unsigned llist_count (const_LList self),
unsigned cnt = 0;
const_LList i = self;
for (; i->next != self; ++cnt, i = i->next);
return cnt;
);
/* private, unlink self some any list but leaves self in a uninitialized state */
LLIST_FUNC (void llist_unlink_fast_ (LList self),
LList nxt = self->next, pre = self->prev;
nxt->prev = pre;
pre->next = nxt;
);
/**
* Remove a node from a list.
* @param self node to be removed
* @return self
*/
LLIST_FUNC (LList llist_unlink (LList self),
llist_unlink_fast_ (self);
return self->next = self->prev = self;
);
/**
* Fix a node which got relocated in memory.
* It is supported to realloc/move list nodes in memory but one must call 'list_relocate' after doing so.
* @param self node which got relocated
* @return self
*/
LLIST_FUNC (LList llist_relocate (LList self),
return self->next->prev = self->prev->next = self;
);
/**
* Insert a node after another.
* @param self node after which we want to insert
* @param next node which shall be inserted after self. Could already linked to a list from where it will be removed.
* @return self
*/
LLIST_FUNC (LList llist_insert_next (LList self, LList next),
llist_unlink_fast_ (next);
self->next->prev = next;
next->prev = self;
next->next = self->next;
self->next = next;
return self;
);
/**
* Insert a node before another.
* @param self node before which we want to insert
* @param prev node which shall be inserted nefore self. Could already linked to a list from where it will be removed.
* @return self
*/
LLIST_FUNC (LList llist_insert_prev (LList self, LList prev),
llist_unlink_fast_ (prev);
self->prev->next = prev;
prev->next = self;
prev->prev = self->prev;
self->prev = prev;
return self;
);
/**
* Move the content of a list after a node in another list.
* @param self node after which we want to insert a list
* @param next rootnode of the list which shall be inserted after self
* @return self
* next is a empty list after this call
*/
LLIST_FUNC (LList llist_insertlist_next (LList self, LList next),
if (!llist_is_empty (next))
{
self->next->prev = next->prev;
self->next = next->next;
next->next->prev = self;
next->prev->next = self->next;
next->prev = next->next = next;
}
return self;
);
/**
* Move the content of a list before a node in another list.
* @param self node before which we want to insert a list
* @param prev rootnode of the list which shall be inserted before self
* @return self
* prev is a empty list after this call
*/
LLIST_FUNC (LList llist_insertlist_prev (LList self, LList prev),
if (!llist_is_empty (prev))
{
self->prev->next = prev->next;
self->prev = prev->prev;
prev->prev->next = self;
prev->next->prev = self->prev;
prev->prev = prev->next = prev;
}
return self;
);
#if 0 //BUG("needs temporary")
/**
* Move a range of nodes after a given node.
* @param self node after which the range shall be inserted
* @param start first node in range to be moved
* @param end node after the last node of the range
*/
LLIST_FUNC (LList llist_insertafter_range (LList self, LList start, LList end),
self->next->prev = end->prev;
end->prev->next = self->next;
end->prev = start->prev;
start->prev->next = end;
self->next = start;
start->prev = self;
return self;
);
#endif
#if 0 //BUG("needs temporary")
/**
* Move a range of nodes before a given node.
* @param self node before which the range shall be inserted
* @param start first node in range to be moved
* @param end node after the last node of the range
*/
LLIST_FUNC (LList llist_inserbefore_range (LList self, LList start, LList end),
self->prev->next = start;
start->prev->next = end;
end->prev = start->prev;
start->prev = self->prev;
self->prev = end->prev;
end->prev->next = self;
return self;
);
#endif
/**
* Swap a node with its next node.
* @param self node to be advaced
* @return self
* advancing will not stop at tail, one has to check that if this is intended
*/
LLIST_FUNC (LList llist_advance (LList self),
LList tmp = self->next->next;
tmp->prev = self;
self->next->prev = self->prev;
self->prev->next = self->next;
self->prev = self->next;
self->next->next = self;
self->next = tmp;
return self;
);
/**
* Swap a node with its previous node.
* @param self node to be retreated
* @return self
* retreating will not stop at head, one has to check that if this is intended
*/
LLIST_FUNC (LList llist_retreat (LList self),
LList tmp = self->prev->prev;
tmp->next = self;
self->prev->next = self->next;
self->next->prev = self->prev;
self->next = self->prev;
self->prev->prev = self;
self->prev = tmp;
return self;
);
/**
* Get next node.
* @param self current node
* @return node after self
* Will not stop at tail
*/
LLIST_FUNC (LList llist_next (const_LList self),
return self->next;
);
/**
* Get previous node.
* @param self current node
* @return node before self
* Will not stop at head
*/
LLIST_FUNC (LList llist_prev (const_LList self),
return self->prev;
);
/**
* Advance a pointer to a node to its next node.
* @param self pointer-to-pointer to the current node
* *self will point to the next node after this call
*/
LLIST_FUNC (void llist_forward (LList_ref self),
*self = (*self)->next;
);
/**
* Retreat a pointer to a node to its previous node.
* @param self pointer-to-pointer to the current node
* *self will point to the previous node after this call
*/
LLIST_FUNC (void llist_backward (LList_ref self),
*self = (*self)->prev;
);
/**
* Get the nth element of a list.
* @param self list to be queried
* @param n nth element after (positive n) or before (negative n) self
* this function does not stop at head/tail.
*/
LLIST_FUNC (LList llist_nth (LList self, int n),
if (n>0)
while (n--)
self = llist_next (self);
else
while (n++)
self = llist_prev (self);
return self;
);
/**
* Get the nth element of a list with a stop node.
* @param self list to be queried
* @param n nth element after (positive n) or before (negative n) self
* @param stop node which will abort the iteration
*/
LLIST_FUNC (LList llist_get_nth_stop (LList self, int n, const_LList stop),
if (n>0)
while (n--)
{
self = llist_next (self);
if (self == stop)
return NULL;
}
else
while (n++)
{
self = llist_prev (self);
if (self == stop)
return NULL;
}
return self;
);
/*
some macros for convenience
*/
#define llist_insert_head(list, element) llist_insert_next (list, element)
#define llist_insert_tail(list, element) llist_insert_prev (list, element)
#define llist_head llist_next
#define llist_tail llist_prev
#endif /* LLIST_H */
/*
// Local Variables:
// mode: C
// c-file-style: "gnu"
// End:
// arch-tag: e8fe4a59-fd55-4c45-b860-5cd1e0771213
// end_of_file
*/

4
src/lib/locking.h
View file

@ -36,8 +36,8 @@ enum cinelerra_lockstate
{
CINELERRA_UNLOCKED,
CINELERRA_LOCKED,
CINELERRA_RLOCKED,
CINELERRA_WLOCKED
CINELERRA_RDLOCKED,
CINELERRA_WRLOCKED
};
#endif

44
src/lib/mutex.c Normal file
View file

@ -0,0 +1,44 @@
/*
mutex.c - mutex
Copyright (C) CinelerraCV
2007, 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
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;
}

136
src/lib/mutex.h Normal file
View file

@ -0,0 +1,136 @@
/*
mutex.h - mutal exclusion locking
Copyright (C) CinelerraCV
2007, 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
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);
/**
* mutexacquirer used to manage the state of a mutex variable.
*/
struct cinelerra_mutexacquirer_struct
{
CinelerraMutex mutex;
enum cinelerra_lockstate state;
};
typedef struct cinelerra_mutexacquirer_struct cinelerra_mutexacquirer;
typedef struct cinelerra_mutexacquirer_struct* CinelerraMutexacquirer;
/* helper function for nobug */
static inline void
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_mutexacquirer \
cinelerra_mutexacquirer NOBUG_CLEANUP(cinelerra_mutexacquirer_ensureunlocked)
/**
* 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 CinelerraMutexacquirer
cinelerra_mutexacquirer_init (CinelerraMutexacquirer 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 mutexacquirer associated with a mutex variable
*/
static inline void
cinelerra_mutexacquirer_lock (CinelerraMutexacquirer 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 mutexacquirer must be unlocked before leaving scope
* @param self mutexacquirer associated with a mutex variable
*/
static inline int
cinelerra_mutexacquirer_unlock (CinelerraMutexacquirer 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

142
src/lib/rwlock.c Normal file
View file

@ -0,0 +1,142 @@
/*
rwlock.c - read/write locks
Copyright (C) CinelerraCV
2007, 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
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 <errno.h>
#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;
}

139
src/lib/rwlock.h Normal file
View file

@ -0,0 +1,139 @@
/*
rwlock.h - read/write locks
Copyright (C) CinelerraCV
2007, 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
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 <pthread.h>
#include <nobug.h>
#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

59
tests/15list.tests Normal file
View file

@ -0,0 +1,59 @@
TESTING "Linked Lists" ./test-llist
TEST "init nodes" basic <<END
out: 1
out: 1
END
TEST "insert nodes" nodeinsert <<END
out: 0
out: 0
out: 1
out: 0
out: 1
out: 1
out: 1
out: 1
out: 3
END
TEST "remaining predicates" predicates <<END
out: 1
out: 1
out: 0
out: 0
out: 1
out: 1
out: 0
out: 1
out: 0
out: 0
END
TEST "unlink" unlink <<END
out: node4 node3 node2 node1 .
out: node1 node4 .
out: 1
out: 1
out: 1
END
TEST "whiles" whiles <<END
out: node4 node3 node2 node1 .
out: .
out: .
END
# not yet tested functions, write tests when needed
PLANNED "llist_relocate"
PLANNED "llist_insertlist_next"
PLANNED "llist_insertlist_prev"
PLANNED "llist_insertafter_range"
PLANNED "llist_inserbefore_range"
PLANNED "llist_advance"
PLANNED "llist_retreat"
PLANNED "list_nth"
PLANNED "llist_get_nth_stop"

8
tests/15locking.tests
View file

@ -6,3 +6,11 @@ return: 134
END
TEST "mutex not unlocked asserts" mutexforgotunlock <<END
return: 134
END

15
tests/Makefile.am
View file

@ -18,7 +18,7 @@
tests_srcdir = $(top_srcdir)/tests
check_PROGRAMS += test-error test-time test-condition
check_PROGRAMS += test-error test-time test-locking test-llist
test_error_SOURCES = $(tests_srcdir)/error/errortest.c
test_error_CPPFLAGS = $(AM_CPPFLAGS) -std=gnu99 -Wall -Werror -I$(top_srcdir)/src/
@ -28,8 +28,15 @@ test_time_SOURCES = $(tests_srcdir)/time/test-time.c
test_time_CPPFLAGS = $(AM_CPPFLAGS) -std=gnu99 -Wall -Werror -I$(top_srcdir)/src/
test_time_LDADD = $(builddir)/libcin3.a -lnobugmt -lpthread -ldl -lm
test_condition_SOURCES = $(tests_srcdir)/locking/test-condition.c
test_condition_CPPFLAGS = $(AM_CPPFLAGS) -std=gnu99 -Wall -Werror -I$(top_srcdir)/src/
test_condition_LDADD = $(builddir)/libcin3.a -lnobugmt -lpthread -ldl -lm
test_locking_SOURCES = \
$(tests_srcdir)/locking/test-locking.c \
$(tests_srcdir)/locking/mutex.c \
$(tests_srcdir)/locking/condition.c
test_locking_CPPFLAGS = $(AM_CPPFLAGS) -std=gnu99 -Wall -Werror -I$(top_srcdir)/src/
test_locking_LDADD = $(builddir)/libcin3.a -lnobugmt -lpthread -ldl -lm
test_llist_SOURCES = $(tests_srcdir)/library/test-llist.c
test_llist_CPPFLAGS = $(AM_CPPFLAGS) -std=gnu99 -Wall -Werror -I$(top_srcdir)/src/
test_llist_LDADD = $(builddir)/libcin3.a -lnobugmt -lpthread -ldl -lm
TESTS = $(tests_srcdir)/test.sh

195
tests/library/test-llist.c Normal file
View file

@ -0,0 +1,195 @@
/*
test-llist.c - test the linked lis lib
Copyright (C) CinelerraCV
2007, 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
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 <stdio.h>
//#include <string.h>
#include "lib/llist.h"
#include "lib/framerate.h"
CINELERRA_ERROR_DEFINE(TEST, "test error");
int
main (int argc, char** argv)
{
NOBUG_INIT;
if (argc == 1)
return 0;
if (!strcmp(argv[1], "basic"))
{
LLIST_AUTO (node1);
llist node2;
llist_init (&node2);
printf ("%d\n", llist_is_empty (&node1));
printf ("%d\n", llist_is_empty (&node2));
}
else if (!strcmp(argv[1], "nodeinsert"))
{
LLIST_AUTO (list);
LLIST_AUTO (node1);
LLIST_AUTO (node2);
LLIST_AUTO (node3);
llist_insert_next (&list, &node1);
printf ("%d\n", llist_is_empty (&list));
printf ("%d\n", llist_is_empty (&node1));
printf ("%d\n", llist_is_single (&node1));
llist_insert_next (&node1, &node2);
printf ("%d\n", llist_is_single (&node1));
llist_insert_prev (&node1, &node3);
printf ("%d\n", llist_next (&list) == &node3);
printf ("%d\n", llist_next (&node3) == &node1);
printf ("%d\n", llist_next (&node1) == &node2);
printf ("%d\n", llist_prev (&list) == &node2);
printf ("%d\n", llist_count (&list));
}
else if (!strcmp(argv[1], "predicates"))
{
LLIST_AUTO (list);
LLIST_AUTO (node1);
LLIST_AUTO (node2);
LLIST_AUTO (node3);
LLIST_AUTO (node4);
LLIST_AUTO (nil);
llist_insert_tail (&list, &node2);
llist_insert_tail (&list, &node3);
llist_insert_tail (&list, &node4);
llist_insert_head (&list, &node1);
printf ("%d\n", llist_is_head (&list, &node1));
printf ("%d\n", llist_is_tail (&list, &node4));
printf ("%d\n", llist_is_head (&list, &node4));
printf ("%d\n", llist_is_tail (&list, &node1));
printf ("%d\n", llist_is_end (&list, &list));
printf ("%d\n", llist_is_member (&list, &node3));
printf ("%d\n", llist_is_member (&list, &nil));
printf ("%d\n", llist_is_before_after (&list, &node1, &node3));
printf ("%d\n", llist_is_before_after (&list, &node3, &node1));
printf ("%d\n", llist_is_before_after (&list, &node1, &nil));
}
else if (!strcmp(argv[1], "unlink"))
{
LLIST_AUTO (list);
LLIST_AUTO (node1);
LLIST_AUTO (node2);
LLIST_AUTO (node3);
LLIST_AUTO (node4);
LLIST_AUTO (nil);
llist_insert_tail (&list, &node2);
llist_insert_tail (&list, &node3);
llist_insert_tail (&list, &node4);
llist_insert_head (&list, &node1);
LLIST_FOREACH_REV (&list, itr)
{
if(itr == &node1) printf ("node1 ");
else if(itr == &node2) printf ("node2 ");
else if(itr == &node3) printf ("node3 ");
else if(itr == &node4) printf ("node4 ");
else printf ("unknown ");
}
printf (".\n");
llist_unlink (&nil);
llist_unlink (&node2);
llist_unlink (&node3);
LLIST_FOREACH (&list, itr)
{
if(itr == &node1) printf ("node1 ");
else if(itr == &node2) printf ("node2 ");
else if(itr == &node3) printf ("node3 ");
else if(itr == &node4) printf ("node4 ");
else printf ("unknown ");
}
printf (".\n");
printf ("%d\n", llist_is_empty (&node2));
printf ("%d\n", llist_is_empty (&node3));
printf ("%d\n", llist_is_empty (&nil));
}
else if (!strcmp(argv[1], "whiles"))
{
LLIST_AUTO (list);
LLIST_AUTO (node1);
LLIST_AUTO (node2);
LLIST_AUTO (node3);
LLIST_AUTO (node4);
LLIST_AUTO (nil);
llist_insert_tail (&list, &node2);
llist_insert_tail (&list, &node3);
llist_insert_tail (&list, &node4);
llist_insert_head (&list, &node1);
LLIST_FOREACH_REV (&list, itr)
{
if(itr == &node1) printf ("node1 ");
else if(itr == &node2) printf ("node2 ");
else if(itr == &node3) printf ("node3 ");
else if(itr == &node4) printf ("node4 ");
else printf ("unknown ");
}
printf (".\n");
LLIST_WHILE_HEAD (&list, head)
llist_unlink (head);
LLIST_FOREACH (&list, itr)
{
if(itr == &node1) printf ("node1 ");
else if(itr == &node2) printf ("node2 ");
else if(itr == &node3) printf ("node3 ");
else if(itr == &node4) printf ("node4 ");
else printf ("unknown ");
}
printf (".\n");
llist_insert_tail (&list, &node2);
llist_insert_tail (&list, &node3);
llist_insert_tail (&list, &node4);
llist_insert_head (&list, &node1);
LLIST_WHILE_TAIL (&list, tail)
llist_unlink (tail);
LLIST_FOREACH (&list, itr)
{
if(itr == &node1) printf ("node1 ");
else if(itr == &node2) printf ("node2 ");
else if(itr == &node3) printf ("node3 ");
else if(itr == &node4) printf ("node4 ");
else printf ("unknown ");
}
printf (".\n");
}
else
return 1;
return 0;
}

49
tests/locking/condition.c Normal file
View file

@ -0,0 +1,49 @@
/*
test condition functions
Copyright (C) CinelerraCV
2007, 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
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_conditionacquirer l;
cinelerra_conditionacquirer_init (&l, &c, CINELERRA_LOCKED);
return 0;
}

32
tests/locking/mutex.c Normal file
View file

@ -0,0 +1,32 @@
/*
test mutex functions
Copyright (C) CinelerraCV
2007, 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
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_mutexacquirer l;
cinelerra_mutexacquirer_init (&l, &m, CINELERRA_LOCKED);
return 0;
}

53
tests/locking/test-locking.c Normal file
View file

@ -0,0 +1,53 @@
/*
test-locking.c - test locking functions
Copyright (C) CinelerraCV
2007, 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
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 <stdio.h>
#include <string.h>
#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;
}