Added some utility things for linked lists.

git-svn-id: https://subversion.cs.uiuc.edu/svn/bang/eoh2009@48 69d76c3e-0761-0410-948c-9895a8bb34fc

src/base/bang-signals.c

@@ -38,9 +38,7 @@ typedef struct _signal_node signal_node;
  * Another read-writer problem, multiple threads can send out the same signal at the same time, but only one thread
  * should be allowed add a signal handler.
  */
-static pthread_mutex_t send_sig_lock[BANG_NUM_SIGS];
-static pthread_mutex_t add_handler_lock[BANG_NUM_SIGS];
-static int sig_senders[BANG_NUM_SIGS];
+BANG_rw_syncro *(sig_locks[BANG_NUM_SIGS]);
 
 /**
  * \brief The handlers for each of the signals is kept in a linked list stored
@@ -79,19 +77,19 @@ static void recursive_sig_free(signal_node *head) {
 }
 
 static void acquire_sig_lock(int signal) {
-	BANG_acquire_read_lock(&(sig_senders[signal]),&(send_sig_lock[signal]),&(add_handler_lock[signal]));
+	BANG_read_lock(sig_locks[signal]);
 }
 
 static void release_sig_lock(int signal) {
-	BANG_release_read_lock(&(sig_senders[signal]),&(send_sig_lock[signal]),&(add_handler_lock[signal]));
+	BANG_read_unlock(sig_locks[signal]);
 }
 
 void BANG_sig_init() {
 	int i;
 
-	signal_handlers = (signal_node**) calloc(BANG_NUM_SIGS,sizeof(signal_node*));
 	for (i = 0; i < BANG_NUM_SIGS; ++i) {
 		signal_handlers[i] = NULL;
+		sig_locks[i] = new_BANG_rw_syncro();
 	}
 }
 
@@ -102,22 +100,22 @@ void BANG_sig_close() {
 	int i;
 	for (i = 0; i < BANG_NUM_SIGS; ++i) {
 		recursive_sig_free(signal_handlers[i]);
+		free_BANG_rw_syncro(sig_locks[i]);
 	}
-	free(signal_handlers);
-	signal_handlers = NULL;
 }
 
 int BANG_install_sighandler(int signal, BANGSignalHandler handler) {
 	/* We need to get a lock on the signal so that people aren't creating
 	 * more that one signal at a time */
-	pthread_mutex_lock(&add_handler_lock[signal]);
+	BANG_write_lock(sig_locks[signal]);
 
 	if (signal_handlers[signal] == NULL) {
 		/* Create a head node if there is none. */
 		signal_handlers[signal] = (signal_node*) malloc(sizeof(signal_node));
 		signal_handlers[signal]->handler = handler;
 		signal_handlers[signal]->next = NULL;
-		pthread_mutex_unlock(&add_handler_lock[signal]);
+
+		BANG_write_unlock(sig_locks[signal]);
 		return 0;
 	} else {
 		signal_node *cur;
@@ -127,13 +125,14 @@ int BANG_install_sighandler(int signal, BANGSignalHandler handler) {
 				cur->next =(signal_node*) malloc(sizeof(signal_node));
 				cur->next->handler = handler;
 				cur->next->next = NULL;
-				pthread_mutex_unlock(&add_handler_lock[signal]);
+
+				BANG_write_unlock(sig_locks[signal]);
 				return 0;
 			}
 		}
 	}
-	///How could it possibly come here!?1?!?
-	pthread_mutex_unlock(&add_handler_lock[signal]);
+	/* How could it possibly come here!?1?!? */
+	BANG_write_unlock(sig_locks[signal]);
 	return -1;
 }
 

src/base/bang-utils.c

@@ -69,3 +69,46 @@ void BANG_release_read_lock(int *readers, pthread_mutex_t *readers_lock, pthread
 		pthread_mutex_unlock(writers_lock);
 	pthread_mutex_unlock(readers_lock);
 }
+
+BANG_node* new_BANG_node(void *data) {
+	BANG_node *node = calloc(1,sizeof(BANG_node));
+
+	node->data = data;
+
+	return node;
+}
+
+void* BANG_list_pop(BANG_linked_list *lst) {
+	if (lst == NULL || lst->head == NULL || lst->tail == NULL) return NULL;
+
+	void *data = lst->head->data;
+
+	if (lst->head == lst->tail) {
+		lst->head = NULL;
+		lst->tail = NULL;
+	} else if (lst->head->next) {
+		lst->head->next->prev = NULL;
+		lst->head = lst->head->next;
+	}
+
+	lst->size--;
+
+	return data;
+}
+
+void BANG_list_append(BANG_linked_list *lst, void *data) {
+	if (lst == NULL || lst->head == NULL || lst->tail == NULL) return;
+
+	BANG_node *node = new_BANG_node(data);
+
+	lst->tail->next = node;
+	node->prev = lst->tail;
+	lst->tail = node;
+
+	lst->size++;
+}
+
+
+size_t BANG_list_get_size(BANG_linked_list *lst) {
+	return lst->size;
+}

src/base/bang-utils.h

@@ -18,14 +18,31 @@ typedef struct {
 	int readers;
 } BANG_rw_syncro;
 
+typedef struct _BANG_node{
+	struct _BANG_node *prev;
+	struct _BANG_node *next;
+	void *data;
+} BANG_node;
+
+typedef struct {
+	BANG_node *head;
+	BANG_node *tail;
+	size_t size;
+} BANG_linked_list;
+
+BANG_node* new_BANG_node(void *data);
+void* BANG_list_pop(BANG_linked_list *lst);
+void BANG_list_append(BANG_linked_list *lst, void *data);
+size_t BANG_list_get_size(BANG_linked_list *lst);
+
 /**
  * \param v1 A bang version.
  * \param v2 Another bang version.
  *
  * \return A comparsion of the two versions.
  *
  * \brief Compares the two versions, 0 if equal, - if less than, + if greater than.
- */ 
+ */
 int BANG_version_cmp(const unsigned char *v1, const unsigned char *v2);
 
 /**
@@ -84,7 +101,6 @@ BANG_rw_syncro* new_BANG_rw_syncro();
  */
 void free_BANG_rw_syncro(BANG_rw_syncro *lck);
 
-
 void BANG_acquire_read_lock(int *readers, pthread_mutex_t *readers_lock, pthread_mutex_t *writers_lock);
 void BANG_release_read_lock(int *readers, pthread_mutex_t *readers_lock, pthread_mutex_t *writers_lock);
 #endif