040dc4c9f04e645178a8d520f361f02f95a05b2c
[pazpar2-moved-to-github.git] / src / sel_thread.c
1 /* This file is part of Pazpar2.
2    Copyright (C) 2006-2009 Index Data
3
4 Pazpar2 is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
18 */
19
20 #if HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include "sel_thread.h"
25 #include <yaz/log.h>
26 #include <yaz/nmem.h>
27 #include <unistd.h>
28 #include <stdlib.h>
29 #include <pthread.h>
30 #include <assert.h>
31
32 struct work_item {
33     void *data;
34     struct work_item *next;
35 };
36
37 static struct work_item *queue_remove_last(struct work_item **q)
38 {
39     struct work_item **work_p = q, *work_this = 0;
40
41     while (*work_p && (*work_p)->next)
42         work_p = &(*work_p)->next;
43     if (*work_p)
44     {
45         work_this = *work_p;
46         *work_p = 0;
47     }
48     return work_this;
49 }
50
51 static void queue_trav(struct work_item *q, void (*f)(void *data))
52 {
53     for (; q; q = q->next)
54         f(q->data);
55 }
56
57 struct sel_thread {
58     int fd[2];
59     NMEM nmem;
60     pthread_t *thread_id;
61     pthread_mutex_t mutex;
62     pthread_cond_t input_data;
63     int stop_flag;
64     int no_threads;
65     struct work_item *input_queue;
66     struct work_item *output_queue;
67     struct work_item *free_queue;
68     void (*work_handler)(void *work_data);
69     void (*work_destroy)(void *work_data);
70 };
71
72 static void *sel_thread_handler(void *vp)
73 {
74     sel_thread_t p = (sel_thread_t) vp;
75
76     while(1)
77     {
78         struct work_item *work_this = 0;
79         /* wait for some work */
80         pthread_mutex_lock(&p->mutex);
81         while (!p->stop_flag && !p->input_queue)
82             pthread_cond_wait(&p->input_data, &p->mutex);
83         /* see if we were waken up because we're shutting down */
84         if (p->stop_flag)
85             break;
86         /* got something. Take the last one out of input_queue */
87
88         assert(p->input_queue);
89         work_this = queue_remove_last(&p->input_queue);
90         assert(work_this);
91
92         pthread_mutex_unlock(&p->mutex);
93
94         /* work on this item */
95         p->work_handler(work_this->data);
96         
97         /* put it back into output queue */
98         pthread_mutex_lock(&p->mutex);
99         work_this->next = p->output_queue;
100         p->output_queue = work_this;
101         pthread_mutex_unlock(&p->mutex);
102
103         /* wake up select/poll with a single byte */
104         write(p->fd[1], "", 1);
105     }        
106     pthread_mutex_unlock(&p->mutex);
107     return 0;
108 }
109
110 sel_thread_t sel_thread_create(void (*work_handler)(void *work_data),
111                                void (*work_destroy)(void *work_data),
112                                int *read_fd, int no_of_threads)
113 {
114     int i;
115     NMEM nmem = nmem_create();
116     sel_thread_t p = nmem_malloc(nmem, sizeof(*p));
117
118     assert(work_handler);
119     /* work_destroy may be NULL */
120     assert(read_fd);
121     assert(no_of_threads >= 1);
122
123     p->nmem = nmem;
124     if (pipe(p->fd))
125     {
126         nmem_destroy(nmem);
127         return 0;
128     }
129     *read_fd = p->fd[0];
130     p->input_queue = 0;
131     p->output_queue = 0;
132     p->free_queue = 0;
133     p->work_handler = work_handler;
134     p->work_destroy = work_destroy;
135
136     p->stop_flag = 0;
137     p->no_threads = no_of_threads;
138     pthread_mutex_init(&p->mutex, 0);
139     pthread_cond_init(&p->input_data, 0);
140
141     p->thread_id = nmem_malloc(nmem, sizeof(*p->thread_id) * p->no_threads);
142     for (i = 0; i < p->no_threads; i++)
143         pthread_create (p->thread_id + i, 0, sel_thread_handler, p);
144     return p;
145 }
146
147 void sel_thread_destroy(sel_thread_t p)
148 {
149     int i;
150     pthread_mutex_lock(&p->mutex);
151     p->stop_flag = 1;
152     pthread_cond_broadcast(&p->input_data);
153     pthread_mutex_unlock(&p->mutex);
154     
155     for (i = 0; i< p->no_threads; i++)
156         pthread_join(p->thread_id[i], 0);
157
158     if (p->work_destroy)
159     {
160         queue_trav(p->input_queue, p->work_destroy);
161         queue_trav(p->output_queue, p->work_destroy);
162     }
163
164     close(p->fd[0]);
165     close(p->fd[1]);
166     pthread_cond_destroy(&p->input_data);
167     pthread_mutex_destroy(&p->mutex);
168     nmem_destroy(p->nmem);
169 }
170
171 void sel_thread_add(sel_thread_t p, void *data)
172 {
173     struct work_item *work_p;
174
175     pthread_mutex_lock(&p->mutex);
176
177     if (p->free_queue)
178     {
179         work_p = p->free_queue;
180         p->free_queue = p->free_queue->next;
181     }
182     else
183         work_p = nmem_malloc(p->nmem, sizeof(*work_p));
184
185     work_p->data = data;
186     work_p->next = p->input_queue;
187     p->input_queue = work_p;
188
189     pthread_cond_signal(&p->input_data);
190     pthread_mutex_unlock(&p->mutex);
191 }
192
193 void *sel_thread_result(sel_thread_t p)
194 {
195     struct work_item *work_this = 0;
196     void *data = 0;
197     char read_buf[1];
198
199     pthread_mutex_lock(&p->mutex);
200
201     /* got something. Take the last one out of output_queue */
202     work_this = queue_remove_last(&p->output_queue);
203     if (work_this)
204     {
205         /* put freed item in free list */
206         work_this->next = p->free_queue;
207         p->free_queue = work_this;
208         
209         data = work_this->data;
210         read(p->fd[0], read_buf, 1);
211     }
212     pthread_mutex_unlock(&p->mutex);
213     return data;
214 }
215
216 /*
217  * Local variables:
218  * c-basic-offset: 4
219  * indent-tabs-mode: nil
220  * End:
221  * vim: shiftwidth=4 tabstop=8 expandtab
222  */