1 /* -*- mode: c; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: t -*-
2 * vim: ts=4 sw=4 noet ai cindent syntax=c
4 * timed_thread.c: Abstraction layer for timed threads
6 * Copyright (C) 2006-2007 Philip Kovacs pkovacs@users.sourceforge.net
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
34 #ifndef HAVE_CLOCK_GETTIME
37 #include "timed_thread.h"
39 /* Abstraction layer for timed threads */
41 static int now(struct timespec *);
44 struct _timed_thread {
45 pthread_t thread; /* thread itself */
46 pthread_attr_t thread_attr; /* thread attributes */
47 pthread_mutex_t cs_mutex; /* critical section mutex */
48 pthread_mutex_t runnable_mutex; /* only for the runnable_cond */
49 pthread_cond_t runnable_cond; /* signalled to stop the thread */
50 void *(*start_routine)(void *); /* thread function to run */
51 void *arg; /* thread function argument */
52 struct timespec interval_time; /* interval_usecs as a struct timespec */
53 struct timespec wait_time; /* absolute future time next timed_thread_test will wait until */
58 /* linked list of created threads */
59 typedef struct _timed_thread_list {
60 timed_thread *p_timed_thread;
61 timed_thread **addr_of_p_timed_thread;
62 struct _timed_thread_list *next;
63 } timed_thread_node, timed_thread_list;
65 static timed_thread_list *p_timed_thread_list_head = NULL;
66 static timed_thread_list *p_timed_thread_list_tail = NULL;
68 int timed_thread_readfd(timed_thread *p_timed_thread)
70 return p_timed_thread->pipefd[0];
73 static int now(struct timespec *abstime)
75 #ifndef HAVE_CLOCK_GETTIME
83 #ifdef HAVE_CLOCK_GETTIME
84 return clock_gettime(CLOCK_REALTIME, abstime);
86 /* fallback to gettimeofday () */
87 if (gettimeofday(&tv, NULL) != 0) {
91 abstime->tv_sec = tv.tv_sec;
92 abstime->tv_nsec = tv.tv_usec * 1000;
97 /* create a timed thread (object creation only) */
98 timed_thread *timed_thread_create(void *start_routine(void *), void *arg,
99 unsigned int interval_usecs)
101 timed_thread *p_timed_thread;
103 assert(start_routine != NULL);
104 assert(interval_usecs >= MINIMUM_INTERVAL_USECS);
106 if ((p_timed_thread = calloc(sizeof(timed_thread), 1)) == 0) {
110 /* create thread pipe (used to tell threads to die) */
111 if (pipe(p_timed_thread->pipefd)) {
115 /* init attributes, e.g. joinable thread */
116 pthread_attr_init(&p_timed_thread->thread_attr);
117 pthread_attr_setdetachstate(&p_timed_thread->thread_attr,
118 PTHREAD_CREATE_JOINABLE);
120 pthread_mutex_init(&p_timed_thread->cs_mutex, NULL);
121 pthread_mutex_init(&p_timed_thread->runnable_mutex, NULL);
123 pthread_cond_init(&p_timed_thread->runnable_cond, NULL);
125 p_timed_thread->start_routine = start_routine;
126 p_timed_thread->arg = arg;
128 /* set wait time to current time */
129 if (now(&p_timed_thread->wait_time)) {
133 /* seconds portion of the microseconds interval */
134 p_timed_thread->interval_time.tv_sec = (time_t) (interval_usecs / 1000000);
135 /* remaining microseconds convert to nanoseconds */
136 p_timed_thread->interval_time.tv_nsec =
137 (long) ((interval_usecs % 1000000) * 1000);
139 /* printf("interval_time.tv_sec = %li, .tv_nsec = %li\n",
140 p_timed_thread->interval_time.tv_sec,
141 p_timed_thread->interval_time.tv_nsec); */
142 return p_timed_thread;
145 /* run a timed thread (drop the thread and run it) */
146 int timed_thread_run(timed_thread *p_timed_thread)
148 return pthread_create(&p_timed_thread->thread, &p_timed_thread->thread_attr,
149 p_timed_thread->start_routine, p_timed_thread->arg);
152 /* destroy a timed thread.
153 * optional addr_of_p_timed_thread to set callers pointer to NULL as a
155 void timed_thread_destroy(timed_thread *p_timed_thread,
156 timed_thread **addr_of_p_timed_thread)
158 assert(p_timed_thread != NULL);
159 assert((addr_of_p_timed_thread == NULL)
160 || (*addr_of_p_timed_thread == p_timed_thread));
162 /* signal thread to stop */
163 pthread_mutex_lock(&p_timed_thread->runnable_mutex);
164 pthread_cond_signal(&p_timed_thread->runnable_cond);
165 p_timed_thread->die = 1;
166 pthread_mutex_unlock(&p_timed_thread->runnable_mutex);
167 write(p_timed_thread->pipefd[1], "die", 3);
169 /* join the terminating thread */
170 if (p_timed_thread->thread) {
171 pthread_join(p_timed_thread->thread, NULL);
175 pthread_attr_destroy(&p_timed_thread->thread_attr);
176 pthread_mutex_destroy(&p_timed_thread->cs_mutex);
177 pthread_mutex_destroy(&p_timed_thread->runnable_mutex);
178 pthread_cond_destroy(&p_timed_thread->runnable_cond);
180 free(p_timed_thread);
181 if (addr_of_p_timed_thread) {
182 *addr_of_p_timed_thread = NULL;
186 /* lock a timed thread for critical section activity */
187 int timed_thread_lock(timed_thread *p_timed_thread)
189 assert(p_timed_thread != NULL);
191 return pthread_mutex_lock(&p_timed_thread->cs_mutex);
194 /* unlock a timed thread after critical section activity */
195 int timed_thread_unlock(timed_thread *p_timed_thread)
197 assert(p_timed_thread != NULL);
199 return pthread_mutex_unlock(&p_timed_thread->cs_mutex);
202 /* thread waits interval_usecs for runnable_cond to be signaled.
203 * returns 1 if signaled, -1 on error, and 0 otherwise.
204 * caller should call timed_thread_exit() on any non-zero return value. */
205 int timed_thread_test(timed_thread *p_timed_thread, int override_wait_time)
207 struct timespec now_time;
210 assert(p_timed_thread != NULL);
212 /* acquire runnable_cond mutex */
213 if (pthread_mutex_lock(&p_timed_thread->runnable_mutex)) {
214 /* could not acquire runnable_cond mutex,
215 * so tell caller to exit thread */
219 if (p_timed_thread->die) {
220 /* if we were kindly asked to die, then die */
224 if (override_wait_time && now(&p_timed_thread->wait_time)) {
228 /* release mutex and wait until future time for runnable_cond to signal */
229 rc = pthread_cond_timedwait(&p_timed_thread->runnable_cond,
230 &p_timed_thread->runnable_mutex, &p_timed_thread->wait_time);
231 /* mutex re-acquired, so release it */
232 pthread_mutex_unlock(&p_timed_thread->runnable_mutex);
234 if (now(&now_time)) {
239 /* runnable_cond was signaled, so tell caller to exit thread */
243 /* absolute future time for next pass */
244 p_timed_thread->wait_time.tv_sec += p_timed_thread->interval_time.tv_sec;
245 p_timed_thread->wait_time.tv_nsec += p_timed_thread->interval_time.tv_nsec;
246 p_timed_thread->wait_time.tv_sec += p_timed_thread->wait_time.tv_nsec / 1000000000;
247 p_timed_thread->wait_time.tv_nsec = p_timed_thread->wait_time.tv_nsec % 1000000000;
249 /* ensure our future wait time is sane */
250 if (p_timed_thread->wait_time.tv_sec > (now_time.tv_sec + p_timed_thread->interval_time.tv_sec) || p_timed_thread->wait_time.tv_sec < now_time.tv_sec) {
251 p_timed_thread->wait_time.tv_sec = now_time.tv_sec + p_timed_thread->interval_time.tv_sec;
252 p_timed_thread->wait_time.tv_nsec = now_time.tv_nsec + p_timed_thread->interval_time.tv_nsec;
253 p_timed_thread->wait_time.tv_sec += p_timed_thread->wait_time.tv_nsec / 1000000000;
254 p_timed_thread->wait_time.tv_nsec = p_timed_thread->wait_time.tv_nsec % 1000000000;
257 /* tell caller not to exit yet */
261 /* exit a timed thread */
262 void timed_thread_exit(timed_thread *p_timed_thread)
264 assert(p_timed_thread != NULL);
266 close(p_timed_thread->pipefd[0]);
267 close(p_timed_thread->pipefd[1]);
272 /* register a timed thread for future destruction via
273 * timed_thread_destroy_registered_threads() */
274 int timed_thread_register(timed_thread *p_timed_thread,
275 timed_thread **addr_of_p_timed_thread)
277 timed_thread_node *p_node;
279 assert((addr_of_p_timed_thread == NULL)
280 || (*addr_of_p_timed_thread == p_timed_thread));
282 if ((p_node = calloc(sizeof(timed_thread_node), 1)) == 0) {
286 p_node->p_timed_thread = p_timed_thread;
287 p_node->addr_of_p_timed_thread = addr_of_p_timed_thread;
290 if (!p_timed_thread_list_tail) {
291 /* first node of empty list */
292 p_timed_thread_list_tail = p_node;
293 p_timed_thread_list_head = p_node;
295 /* add node to tail of non-empty list */
296 p_timed_thread_list_tail->next = p_node;
297 p_timed_thread_list_tail = p_node;
303 /* destroy all registered timed threads */
304 void timed_thread_destroy_registered_threads(void)
306 timed_thread_node *p_node, *p_next;
308 for (p_node = p_timed_thread_list_head; p_node; p_node = p_next) {
309 p_next = p_node->next;
310 timed_thread_destroy(p_node->p_timed_thread,
311 p_node->addr_of_p_timed_thread);
316 p_timed_thread_list_head = NULL;
317 p_timed_thread_list_tail = NULL;