Implemented the destroy_counter on HTTP commands. Only destroy HTTP session if no...

[pazpar2-moved-to-github.git] / src / sel_thread.c

diff --git a/src/sel_thread.c b/src/sel_thread.c
index f086fa6..0677761 100644 (file)
--- a/src/sel_thread.c
+++ b/src/sel_thread.c
@@ -1,7 +1,5 @@
-/* $Id: sel_thread.c,v 1.3 2007-04-20 11:44:58 adam Exp $
-   Copyright (c) 2006-2007, Index Data.
-
-This file is part of Pazpar2.
+/* This file is part of Pazpar2.
+   Copyright (C) 2006-2010 Index Data
 
 Pazpar2 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
@@ -14,13 +12,13 @@ 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 Pazpar2; see the file LICENSE.  If not, write to the
-Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.
- */
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
 
 #if HAVE_CONFIG_H
-#include "cconfig.h"
+#include <config.h>
 #endif
 
 #include "sel_thread.h"
@@ -50,24 +48,34 @@ static struct work_item *queue_remove_last(struct work_item **q)
     return work_this;
 }
 
+static void queue_trav(struct work_item *q, void (*f)(void *data))
+{
+    for (; q; q = q->next)
+        f(q->data);
+}
+
 struct sel_thread {
     int fd[2];
     NMEM nmem;
-    pthread_t thread_id;
+    pthread_t *thread_id;
     pthread_mutex_t mutex;
     pthread_cond_t input_data;
     int stop_flag;
+    int no_threads;
     struct work_item *input_queue;
     struct work_item *output_queue;
     struct work_item *free_queue;
-    void (*work_handler)(void *work_data);;
+    void (*work_handler)(void *work_data);
+    void (*work_destroy)(void *work_data);
 };
 
+static int input_queue_length = 0;
+
 static void *sel_thread_handler(void *vp)
 {
     sel_thread_t p = (sel_thread_t) vp;
 
-    while(1)
+    while (1)
     {
         struct work_item *work_this = 0;
         /* wait for some work */
@@ -81,6 +89,8 @@ static void *sel_thread_handler(void *vp)
 
         assert(p->input_queue);
         work_this = queue_remove_last(&p->input_queue);
+        input_queue_length--;
+        yaz_log(YLOG_DEBUG, "input queue length after pop: %d", input_queue_length);
         assert(work_this);
 
         pthread_mutex_unlock(&p->mutex);
@@ -95,18 +105,25 @@ static void *sel_thread_handler(void *vp)
         pthread_mutex_unlock(&p->mutex);
 
         /* wake up select/poll with a single byte */
-        write(p->fd[1], "", 1);
+        (void) write(p->fd[1], "", 1);
     }        
     pthread_mutex_unlock(&p->mutex);
     return 0;
 }
 
 sel_thread_t sel_thread_create(void (*work_handler)(void *work_data),
-                               int *read_fd)
+                               void (*work_destroy)(void *work_data),
+                               int *read_fd, int no_of_threads)
 {
+    int i;
     NMEM nmem = nmem_create();
     sel_thread_t p = nmem_malloc(nmem, sizeof(*p));
 
+    assert(work_handler);
+    /* work_destroy may be NULL */
+    assert(read_fd);
+    assert(no_of_threads >= 1);
+
     p->nmem = nmem;
     if (pipe(p->fd))
     {
@@ -118,22 +135,35 @@ sel_thread_t sel_thread_create(void (*work_handler)(void *work_data),
     p->output_queue = 0;
     p->free_queue = 0;
     p->work_handler = work_handler;
+    p->work_destroy = work_destroy;
 
     p->stop_flag = 0;
+    p->no_threads = no_of_threads;
     pthread_mutex_init(&p->mutex, 0);
     pthread_cond_init(&p->input_data, 0);
-    pthread_create (&p->thread_id, 0, sel_thread_handler, p);
+
+    p->thread_id = nmem_malloc(nmem, sizeof(*p->thread_id) * p->no_threads);
+    for (i = 0; i < p->no_threads; i++)
+        pthread_create(p->thread_id + i, 0, sel_thread_handler, p);
     return p;
 }
 
 void sel_thread_destroy(sel_thread_t p)
 {
+    int i;
     pthread_mutex_lock(&p->mutex);
     p->stop_flag = 1;
     pthread_cond_broadcast(&p->input_data);
     pthread_mutex_unlock(&p->mutex);
     
-    pthread_join(p->thread_id, 0);
+    for (i = 0; i< p->no_threads; i++)
+        pthread_join(p->thread_id[i], 0);
+
+    if (p->work_destroy)
+    {
+        queue_trav(p->input_queue, p->work_destroy);
+        queue_trav(p->output_queue, p->work_destroy);
+    }
 
     close(p->fd[0]);
     close(p->fd[1]);
@@ -159,7 +189,8 @@ void sel_thread_add(sel_thread_t p, void *data)
     work_p->data = data;
     work_p->next = p->input_queue;
     p->input_queue = work_p;
-
+    input_queue_length++;
+    yaz_log(YLOG_DEBUG, "sel_thread_add: Input queue length after push: %d", input_queue_length);
     pthread_cond_signal(&p->input_data);
     pthread_mutex_unlock(&p->mutex);
 }
@@ -181,7 +212,7 @@ void *sel_thread_result(sel_thread_t p)
         p->free_queue = work_this;
         
         data = work_this->data;
-        read(p->fd[0], read_buf, 1);
+        (void) read(p->fd[0], read_buf, 1);
     }
     pthread_mutex_unlock(&p->mutex);
     return data;
@@ -190,7 +221,9 @@ void *sel_thread_result(sel_thread_t p)
 /*
  * Local variables:
  * c-basic-offset: 4
+ * c-file-style: "Stroustrup"
  * indent-tabs-mode: nil
  * End:
  * vim: shiftwidth=4 tabstop=8 expandtab
  */
+