try to make data structures thread save by using a mutex

include/tr/hash.h

@@ -28,16 +28,16 @@
 #include "trbase.h"
 #include "tr/tree.h"
 
-#define TR_HASH_IS_EMPTY(h)	((h)->root)
+#define TR_HASH_IS_EMPTY(h)	((h)->tree->root)
 
 TR_CLASS(TR_Hash) {
-	TR_Tree root;
+	TR_Tree tree;
 	int     cleanup_no_free;
 };
 TR_INSTANCE_INIT(TR_Hash);
 TR_CLASSVARS_DECL(TR_Hash) {};
 
-#define TR_hashEmpty(hash) (NULL == (hash)->root)
+#define TR_hashEmpty(hash) (NULL == (hash)->tree->root)
 
 void * TR_hashAdd(TR_Hash, void *);
 void * TR_hashDelete(TR_Hash, const char *, size_t);

include/tr/queue.h

@@ -26,6 +26,7 @@
 #ifndef __TR_QUEUE_H__
 #define __TR_QUEUE_H__
 
+#include <pthread.h>
 #include <sys/types.h>
 
 #include "trbase.h"
@@ -35,6 +36,8 @@ TR_CLASS(TR_Queue) {
 	void *    msg;
 	TR_Queue  next;
 
+	pthread_mutex_t lock;
+
 	/**
 	 * first and last are only available in the initial queue
 	 * element (the root). This elelment does not contain any message

include/tr/tree.h

@@ -23,17 +23,26 @@
 #ifndef __TR_TREE_H__
 #define __TR_TREE_H__
 
+#include <pthread.h>
+
 #include "tr/tree_macros.h"
 #include "trbase.h"
 
-TR_CLASS(TR_Tree) {
+TR_CLASS(TR_TreeNode) {
 	void * data;
 
 	TR_rbColor color;
 
-	TR_Tree parent;
-	TR_Tree left;
-	TR_Tree right;
+	TR_TreeNode parent;
+	TR_TreeNode left;
+	TR_TreeNode right;
+};
+TR_INSTANCE_INIT(TR_TreeNode);
+TR_CLASSVARS_DECL(TR_TreeNode) {};
+
+TR_CLASS(TR_Tree) {
+	TR_TreeNode     root;
+	pthread_mutex_t lock;
 };
 TR_INSTANCE_INIT(TR_Tree);
 TR_CLASSVARS_DECL(TR_Tree) {};
@@ -42,10 +51,10 @@ typedef int  (*TR_TreeComp)(const void *, const void *);
 typedef void (*TR_TreeAction)(const void *, const void *, const int);
 
 void * TR_treeFind(TR_Tree, const void *, TR_TreeComp);
-void * TR_treeInsert(TR_Tree *, const void *, TR_TreeComp);
-void * TR_treeDelete(TR_Tree *, const void *, TR_TreeComp);
+void * TR_treeInsert(TR_Tree, const void *, TR_TreeComp);
+void * TR_treeDelete(TR_Tree, const void *, TR_TreeComp);
 void   TR_treeWalk(TR_Tree, const void *, TR_TreeAction);
-void   TR_treeDestroy(TR_Tree *, TR_TreeAction);
+void   TR_treeDestroy(TR_Tree, TR_TreeAction);
 
 #endif // __TR_TREE_H__
 

src/Makefile.am

@@ -11,7 +11,7 @@ TRDATALIBS = cbuf/libcbuf.la \
 lib_LTLIBRARIES = libtrdata.la
 
 libtrdata_la_SOURCES =
-libtrdata_la_CFLAGS  = $(AM_CFLAGS)
+libtrdata_la_CFLAGS  = $(AM_CFLAGS) -lpthread
 libtrdata_la_LIBADD  = $(TRDATALIBS)
 
 SUBDIRS = cbuf hash queue tree

src/hash/add.c

@@ -48,7 +48,7 @@ hashAddComp(const void * a, const void * b)
 void *
 TR_hashAdd(TR_Hash this, void * operand)
 {
-	void * found = TR_treeInsert(&this->root, operand, hashAddComp);
+	void * found = TR_treeInsert(this->tree, operand, hashAddComp);
 
 	if (NULL == found) {
 		return NULL;

src/hash/cleanup.c

@@ -36,10 +36,12 @@ void
 TR_hashCleanup(TR_Hash this)
 {
 	if (this->cleanup_no_free) {
-		TR_treeDestroy(&(this->root), NULL);
+		TR_treeDestroy(this->tree, NULL);
 	} else {
-		TR_treeDestroy(&(this->root), tDelete);
+		TR_treeDestroy(this->tree, tDelete);
 	}
+
+	TR_delete(this->tree);
 }
 
 // vim: set ts=4 sw=4:

src/hash/delete.c

@@ -51,7 +51,7 @@ TR_hashDelete(TR_Hash this, const char * search, size_t nsearch)
 	unsigned long   hash  = TR_sdbm((const unsigned char *)search, nsearch);
 	void          * found = NULL;
 
-	found = TR_treeDelete(&(this->root), &hash, hashDeleteComp);
+	found = TR_treeDelete(this->tree, &hash, hashDeleteComp);
 
 	return found;
 }
@@ -59,7 +59,7 @@ TR_hashDelete(TR_Hash this, const char * search, size_t nsearch)
 void *
 TR_hashDeleteByVal(TR_Hash this, unsigned long hash)
 {
-	void * found = TR_treeDelete(&(this->root), &hash, hashDeleteComp);
+	void * found = TR_treeDelete(this->tree, &hash, hashDeleteComp);
 
 	return found;
 }

src/hash/each.c

@@ -42,7 +42,7 @@ TR_hashEach(
 {
 	cb = callback;
 
-	TR_treeWalk(this->root, data, walk);
+	TR_treeWalk(this->tree, data, walk);
 }
 
 // vim: set ts=4 sw=4:

src/hash/get.c

@@ -52,7 +52,7 @@ void *
 TR_hashGet(TR_Hash this, const char * search, size_t nsearch)
 {
 	unsigned long   hash  = TR_sdbm((const unsigned char *)search, nsearch);
-	void          * found = TR_treeFind(this->root, &hash, hashGetComp);
+	void          * found = TR_treeFind(this->tree, &hash, hashGetComp);
 
 	return found;
 }
@@ -60,7 +60,7 @@ TR_hashGet(TR_Hash this, const char * search, size_t nsearch)
 void *
 TR_hashGetByVal(TR_Hash this, unsigned long hash)
 {
-	void * found = TR_treeFind(this->root, &hash, hashGetComp);
+	void * found = TR_treeFind(this->tree, &hash, hashGetComp);
 
 	return found;
 }

src/hash/get_first.c

@@ -27,7 +27,7 @@
 void *
 TR_hashGetFirst(TR_Hash this)
 {
-	return this->root;
+	return this->tree->root;
 }
 
 // vim: set ts=4 sw=4:

src/hash/hash.c

@@ -31,6 +31,10 @@ static
 int
 hashCtor(void * _this, va_list * params)
 {
+	TR_Hash this = _this;
+
+	this->tree = TR_new(TR_Tree);
+
 	return 0;
 }
 
@@ -41,6 +45,8 @@ hashDtor(void * _this)
 	TR_Hash this = _this;
 
 	TR_hashCleanup(this);
+
+	TR_delete(this->tree);
 }
 
 TR_INIT_IFACE(TR_Class, hashCtor, hashDtor, NULL);

src/queue/delete.c

@@ -26,9 +26,16 @@
 void
 TR_queueDelete(TR_Queue this, void * msg)
 {
-	TR_Queue node, parent = TR_queueFindParent(this, msg);
+	TR_Queue node, parent;
+	
+	pthread_mutex_lock(&(this->lock));
 
-	if (! parent) return;
+	parent = TR_queueFindParent(this, msg);
+
+	if (! parent) {
+		pthread_mutex_unlock(&(this->lock));
+		return;
+	}
 
 	node = parent->next;
 	parent->next = node->next;
@@ -40,6 +47,8 @@ TR_queueDelete(TR_Queue this, void * msg)
 	}
 	TR_delete(node);
 	this->nmsg--;
+
+	pthread_mutex_unlock(&(this->lock));
 }
 
 // vim: set ts=4 sw=4:

src/queue/destroy.c

@@ -21,6 +21,7 @@
  */
 
 #include <stdarg.h>
+#include <pthread.h>
 
 #include "trbase.h"
 #include "tr/queue.h"
@@ -30,6 +31,8 @@ TR_queueDestroy(TR_Queue this)
 {
 	TR_Queue node = this->first;
 	
+	pthread_mutex_lock(&(this->lock));
+
 	while (NULL != node) {
 		TR_Queue next = node->next;
 		if (this->free_msgs) {
@@ -41,6 +44,8 @@ TR_queueDestroy(TR_Queue this)
 
 	this->first = this->next = this->last = NULL;
 	this->nmsg = 0;
+
+	pthread_mutex_unlock(&(this->lock));
 }
 
 // vim: set ts=4 sw=4:

src/queue/get.c

@@ -20,6 +20,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <pthread.h>
+
 #include "trbase.h"
 #include "tr/queue.h"
 
@@ -29,7 +31,10 @@ TR_queueGet(TR_Queue this)
 	TR_Queue   first;
 	void     * msg;
 
+	pthread_mutex_lock(&(this->lock));
+
 	if (NULL == this->first) {
+		pthread_mutex_unlock(&(this->lock));
 		return NULL;
 	}
 
@@ -45,6 +50,8 @@ TR_queueGet(TR_Queue this)
 	this->first = first;
 	this->nmsg--;
 
+	pthread_mutex_unlock(&(this->lock));
+
 	return msg;
 }
 

src/queue/put.c

@@ -20,6 +20,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <pthread.h>
+
 #include "trbase.h"
 #include "tr/queue.h"
 
@@ -28,6 +30,8 @@ TR_queuePut(TR_Queue this, void * msg)
 {
 	TR_Queue node = (this->last)? this->last : this;
 
+	pthread_mutex_lock(&(this->lock));
+
 	node->next = TR_new(TR_Queue);
 	this->last = node->next;
 
@@ -37,6 +41,8 @@ TR_queuePut(TR_Queue this, void * msg)
 
 	node->next->msg = msg;
 	this->nmsg++;
+
+	pthread_mutex_unlock(&(this->lock));
 }
 
 // vim: set ts=4 sw=4:

src/queue/put_first.c

@@ -20,6 +20,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <pthread.h>
+
 #include "trbase.h"
 #include "tr/queue.h"
 
@@ -28,11 +30,15 @@ TR_queuePutFirst(TR_Queue this, void * msg)
 {
 	TR_Queue current_first = this->first;
 
+	pthread_mutex_lock(&(this->lock));
+
 	this->first = this->next = TR_new(TR_Queue);
 	this->first->next = current_first;
 	this->first->msg  = msg;
 	this->last        = this->last ? this->last : this->first;
 	this->nmsg++;
+
+	pthread_mutex_unlock(&(this->lock));
 }
 
 // vim: set ts=4 sw=4:

src/queue/queue.c

@@ -21,6 +21,7 @@
  */
 
 #include <stdarg.h>
+#include <pthread.h>
 
 #include "trbase.h"
 #include "tr/queue.h"
@@ -32,6 +33,7 @@ queueCtor(void * _this, va_list * params)
 	TR_Queue this = _this;
 
 	this->free_msgs = 1;
+	pthread_mutex_init(&(this->lock), NULL);
 
 	return 0;
 }
@@ -40,7 +42,10 @@ static
 void
 queueDtor(void * _this)
 {
-	TR_queueDestroy((TR_Queue)_this);
+	TR_Queue this = _this;
+
+	TR_queueDestroy(this);
+	pthread_mutex_destroy(&(this->lock));
 }
 
 TR_INIT_IFACE(TR_Class, queueCtor, queueDtor, NULL);

src/tree/Makefile.am

@@ -2,6 +2,7 @@ ACLOCAL_AMFLAGS = -I m4
 AUTOMAKE_OPTIONS = subdir-objects
 
 TREE = tree.c \
+       tree_node.c \
        find.c \
        insert.c \
        delete.c \

src/tree/delete.c

@@ -20,18 +20,21 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <pthread.h>
+
 #include "trbase.h"
 #include "tr/tree.h"
 
 void *
-TR_treeDelete(TR_Tree * this, const void * search, TR_TreeComp comp)
+TR_treeDelete(TR_Tree this, const void * search, TR_TreeComp comp)
 {
-	TR_Tree node = *this;
-	TR_Tree del_node;
-	TR_Tree sibling;
-	int     found;
+	TR_TreeNode   node = this->root;
+	TR_TreeNode   del_node;
+	TR_TreeNode   sibling;
+	int           found;
+	void        * data;
 
-	void    * data;
+	pthread_mutex_lock(&(this->lock));
 
 	TR_TREE_FIND(node, search, found, comp);
 
@@ -39,6 +42,7 @@ TR_treeDelete(TR_Tree * this, const void * search, TR_TreeComp comp)
 	 * nothing was found...return NULL to indicate this.
 	 */
 	if (found != 0) {
+		pthread_mutex_unlock(&(this->lock));
 		return NULL;
 	}
 
@@ -57,7 +61,7 @@ TR_treeDelete(TR_Tree * this, const void * search, TR_TreeComp comp)
 	 * out inOrderSuccessor and remove the inOrderSuccessor.
 	 */
 	if (NULL != TR_TREE_LEFT(node) && NULL != TR_TREE_RIGHT(node)) {
-		TR_Tree successor;
+		TR_TreeNode successor;
 		
 		TR_TREE_INORDER_SUCC(node, successor);
 
@@ -66,12 +70,12 @@ TR_treeDelete(TR_Tree * this, const void * search, TR_TreeComp comp)
 	}
 
 	{
-		TR_Tree child = TR_TREE_CHILD(node);
+		TR_TreeNode child = TR_TREE_CHILD(node);
 
 		/*
 		 * if we still have one child replace ourself with it.
 		 */
-		TR_TREE_REPLACE_NODE(this, node, child);
+		TR_TREE_REPLACE_NODE(&(this->root), node, child);
 
 		/*
 		 * and finally delete the node...and prepare ourselfs
@@ -81,6 +85,7 @@ TR_treeDelete(TR_Tree * this, const void * search, TR_TreeComp comp)
 			if (NULL != child && rbRed == child->color) {
 				child->color = rbBlack;
 				TR_delete(node);
+				pthread_mutex_unlock(&(this->lock));
 				return data;
 			} else {
 				del_node = node;
@@ -94,6 +99,7 @@ TR_treeDelete(TR_Tree * this, const void * search, TR_TreeComp comp)
 			}
 		} else {
 			TR_delete(node);
+			pthread_mutex_unlock(&(this->lock));
 			return data;
 		}
 	}
@@ -105,9 +111,12 @@ TR_treeDelete(TR_Tree * this, const void * search, TR_TreeComp comp)
 	 * rebalancing process...(this does not make much sense, but
 	 * to be honest I don't know now.)
 	 */
-	TR_TREE_BALANCE_DELETE(this, node, sibling);
+	TR_TREE_BALANCE_DELETE(&(this->root), node, sibling);
 
 	TR_delete(del_node);
+	
+	pthread_mutex_unlock(&(this->lock));
+
 	return data;
 }
 

src/tree/destroy.c

@@ -24,11 +24,11 @@
 #include "tr/tree.h"
 
 void
-TR_treeDestroy(TR_Tree * this, TR_TreeAction action)
+TR_treeDestroy(TR_Tree this, TR_TreeAction action)
 {
-    TR_Tree previous = * this;
-    TR_Tree node     = * this;
-    int  depth    = 1;
+    TR_TreeNode previous = this->root;
+    TR_TreeNode node     = this->root;
+    int         depth    = 1;
     
     /*
      * I think this has something like O(n+log(n)) on a ballanced
@@ -44,7 +44,7 @@ TR_treeDestroy(TR_Tree * this, TR_TreeAction action)
 				|| previous == TR_TREE_LEFT(node)) && NULL == TR_TREE_RIGHT(node))
 				|| previous == TR_TREE_RIGHT(node)) {
             
-            TR_Tree parent = TR_TREE_PARENT(node);
+            TR_TreeNode parent = TR_TREE_PARENT(node);
             
 			if (action) {
 				action(node->data, NULL, depth);
@@ -82,7 +82,7 @@ TR_treeDestroy(TR_Tree * this, TR_TreeAction action)
         }
     }
 	
-	*this = NULL;
+	this->root = NULL;
 }
 
 // vim: set ts=4 sw=4:

src/tree/find.c

@@ -25,11 +25,16 @@
 void *
 TR_treeFind(TR_Tree this, const void * search, TR_TreeComp comp)
 {
-	int found;
+	int         found;
+	TR_TreeNode node = this->root;
 
-	TR_TREE_FIND(this, search, found, comp);
+	pthread_mutex_lock(&(this->lock));
 
-	return found == 0 ? this->data : NULL;
+	TR_TREE_FIND(node, search, found, comp);
+
+	pthread_mutex_unlock(&(this->lock));
+
+	return found == 0 ? node->data : NULL;
 }
 
 // vim: set ts=4 sw=4:

src/tree/insert.c

@@ -20,16 +20,20 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <pthread.h>
+
 #include "trbase.h"
 #include "tr/tree.h"
 
 void *
-TR_treeInsert(TR_Tree * this, const void * search, TR_TreeComp comp)
+TR_treeInsert(TR_Tree this, const void * search, TR_TreeComp comp)
 {
-	TR_Tree node     = *this;
-	TR_Tree new_node = NULL;
+	TR_TreeNode node     = this->root;
+	TR_TreeNode new_node = NULL;
 	int     found;
 
+	pthread_mutex_lock(&(this->lock));
+
 	/*
 	 * insert the node or return the one in tree if comparison
 	 * succeeds.
@@ -39,11 +43,13 @@ TR_treeInsert(TR_Tree * this, const void * search, TR_TreeComp comp)
 		 * if the root is NULL we simple add the element and set
 		 * node to it.
 		 */
-		*this = node = new_node = TR_new(TR_Tree, search);
+		this->root = node = new_node = TR_new(TR_TreeNode, search);
 	} else {
 		TR_TREE_FIND(node, search, found, comp);
 
 		if (found == 0) {
+			pthread_mutex_unlock(&(this->lock));
+
 			// This differs from tsearch, which is the posix equivalent to
 			// this function in that it will not replace an existing value.
 			// If there is a value for the given key in the tree it will be
@@ -55,11 +61,11 @@ TR_treeInsert(TR_Tree * this, const void * search, TR_TreeComp comp)
 		} else {
 			// not found
 			if (0 < found) {
-				node->left = TR_new(TR_Tree, search);
+				node->left = TR_new(TR_TreeNode, search);
 				node->left->parent = node;
 				node = new_node = node->left;
 			} else {
-				node->right = TR_new(TR_Tree, search);
+				node->right = TR_new(TR_TreeNode, search);
 				node->right->parent = node;
 				node = new_node = node->right;
 			}
@@ -70,7 +76,9 @@ TR_treeInsert(TR_Tree * this, const void * search, TR_TreeComp comp)
 	 * we expect node not to be NULL and pointing to our
 	 * new node at this point...now rabalance the tree
 	 */
-	TR_TREE_BALANCE_INSERT(this, node);
+	TR_TREE_BALANCE_INSERT(&(this->root), node);
+
+	pthread_mutex_unlock(&(this->lock));
 
 	return new_node->data;
 }

src/tree/tree.c

@@ -33,11 +33,8 @@ treeCtor(void * _this, va_list * params)
 {
 	TR_Tree this = _this;
 
-	this->data   = va_arg(*params, void *);
-	this->color  = rbRed;
-	this->parent = NULL;
-	this->left   = NULL;
-	this->right  = NULL;
+	this->root = NULL;
+	pthread_mutex_init(&(this->lock), NULL);
 
 	return 0;
 }
@@ -46,6 +43,8 @@ static
 void
 treeDtor(void * _this)
 {
+	TR_Tree this = _this;
+	pthread_mutex_destroy(&(this->lock));
 }
 
 TR_INIT_IFACE(TR_Class, treeCtor, treeDtor, NULL);

src/tree/tree_node.c

@@ -0,0 +1,50 @@
+/**
+ * \file
+ *
+ * \author	Georg Hopp
+ *
+ * \copyright
+ * Copyright © 2014 Georg Hopp
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _GNU_SOURCE
+
+#include <stdarg.h>
+
+#include "trbase.h"
+#include "tr/tree.h"
+
+static
+int
+treeNodeCtor(void * _this, va_list * params)
+{
+	TR_TreeNode this = _this;
+
+	this->data   = va_arg(*params, void *);
+	this->color  = rbRed;
+	this->parent = NULL;
+	this->left   = NULL;
+	this->right  = NULL;
+
+	return 0;
+}
+
+static void treeNodeDtor(void * _this) {}
+
+TR_INIT_IFACE(TR_Class, treeNodeCtor, treeNodeDtor, NULL);
+TR_CREATE_CLASS(TR_TreeNode, NULL, NULL, TR_IF(TR_Class));
+
+// vim: set ts=4 sw=4:

src/tree/walk.c

@@ -25,9 +25,9 @@
 void
 TR_treeWalk(TR_Tree this, const void * data, TR_TreeAction action)
 {
-	TR_Tree previous = this;
-	TR_Tree node     = this;
-	int  depth       = 1;
+	TR_TreeNode previous = this->root;
+	TR_TreeNode node     = this->root;
+	int         depth    = 1;
 
 	while (NULL != node) {
 		if (previous == TR_TREE_RIGHT(node)) {