trunk/src/timer.c

/*
 *  Copyright (C) 2006-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: timer.c,v 1.11 2007/06/18 04:23:19 debug Exp $
 *
 *  Timer framework. This is used by emulated clocks.
 */

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>

#include "misc.h"
#include "timer.h"


/*  #define TEST  */


struct timer {
        struct timer    *next;

        double          freq;
        void            (*timer_tick)(struct timer *timer, void *extra);
        void            *extra;

        double          interval;
        double          next_tick_at;
};

static struct timer *first_timer = NULL;
struct timeval timer_start_tv;
static double timer_freq;
static int timer_countdown_to_next_gettimeofday;
static double timer_current_time;
static double timer_current_time_step;

static int timer_is_running;

#define SECONDS_BETWEEN_GETTIMEOFDAY_SYNCH      1.65


/*
 *  timer_add():
 *
 *  Adds a virtual timer to the list of timers.
 *
 *  Return value is a pointer to a timer struct.
 */
struct timer *timer_add(double freq, void (*timer_tick)(struct timer *timer,
        void *extra), void *extra)
{
        struct timer *newtimer;

        CHECK_ALLOCATION(newtimer = malloc(sizeof(struct timer)));

        if (freq <= 0.00000001)
                freq = 0.00000001;

        newtimer->freq = freq;
        newtimer->timer_tick = timer_tick;
        newtimer->extra = extra;

        newtimer->interval = 1.0 / freq;
        newtimer->next_tick_at = timer_current_time + newtimer->interval;

        newtimer->next = first_timer;
        first_timer = newtimer;

        return newtimer;
}


/*
 *  timer_remove():
 *
 *  Removes a virtual timer from the list of timers.
 */
void timer_remove(struct timer *t)
{
        struct timer *prev = NULL, *cur = first_timer;

        while (cur != NULL && cur != t) {
                prev = cur;
                cur = cur->next;
        }

        if (cur == t) {
                if (prev == NULL)
                        first_timer = cur->next;
                else
                        prev->next = cur->next;
                free(cur);
        } else {
                fprintf(stderr, "attempt to remove timer %p which "
                    "doesn't exist. aborting\n", t);
                exit(1);
        }
}


/*
 *  timer_update_frequency():
 *
 *  Changes the frequency of an existing timer.
 */
void timer_update_frequency(struct timer *t, double new_freq)
{
        if (t->freq == new_freq)
                return;

        t->freq = new_freq;

        if (new_freq <= 0.00000001)
                new_freq = 0.00000001;

        t->interval = 1.0 / new_freq;
        t->next_tick_at = timer_current_time + t->interval;
}


/*
 *  timer_tick():
 *
 *  Timer tick handler. This is where the interesting stuff happens.
 */
static void timer_tick(int signal_nr)
{
        struct timer *timer = first_timer;
        struct timeval tv;

        timer_current_time += timer_current_time_step;

        if ((--timer_countdown_to_next_gettimeofday) < 0) {
                gettimeofday(&tv, NULL);
                tv.tv_sec -= timer_start_tv.tv_sec;
                tv.tv_usec -= timer_start_tv.tv_usec;
                if (tv.tv_usec < 0) {
                        tv.tv_usec += 1000000;
                        tv.tv_sec --;
                }

#ifdef TIMER_DEBUG
                /*  For debugging/testing:  */
                {
                        double diff = tv.tv_usec * 0.000001 + tv.tv_sec
                            - timer_current_time;
                        printf("timer: lagging behind %f seconds\n", diff);
                }
#endif

                /*  Get exponentially closer to the real time, instead of
                    just changing to it directly:  */
                timer_current_time = ( (tv.tv_usec * 0.000001 + tv.tv_sec) +
                    timer_current_time ) / 2;

                timer_countdown_to_next_gettimeofday = timer_freq *
                    SECONDS_BETWEEN_GETTIMEOFDAY_SYNCH;
        }

        while (timer != NULL) {
                while (timer_current_time >= timer->next_tick_at) {
                        timer->timer_tick(timer, timer->extra);
                        timer->next_tick_at += timer->interval;
                }

                timer = timer->next;
        }

#ifdef TEST
        printf("T"); fflush(stdout);
#endif
}


/*
 *  timer_start():
 *
 *  Set the interval timer to timer_freq Hz, and install the signal handler.
 */
void timer_start(void)
{
        struct timer *timer = first_timer;
        struct itimerval val;
        struct sigaction saction;

        if (timer_is_running)
                return;

        timer_is_running = 1;

        gettimeofday(&timer_start_tv, NULL);
        timer_current_time = 0.0;

        /*  Reset all timers:  */
        while (timer != NULL) {
                timer->next_tick_at = timer->interval;
                timer = timer->next;
        }
        val.it_interval.tv_sec = 0;
        val.it_interval.tv_usec = 1000000.0 / timer_freq;
        val.it_value.tv_sec = 0;
        val.it_value.tv_usec = 1000000.0 / timer_freq;

        memset(&saction, 0, sizeof(saction));
        saction.sa_handler = timer_tick;

        sigaction(SIGALRM, &saction, NULL);

        setitimer(ITIMER_REAL, &val, NULL);
}


/*
 *  timer_stop():
 *
 *  Deinstall the signal handler, and disable the interval timer.
 */
void timer_stop(void)
{
        struct itimerval val;
        struct sigaction saction;

        if (!timer_is_running)
                return;

        timer_is_running = 0;

        val.it_interval.tv_sec = 0;
        val.it_interval.tv_usec = 0;
        val.it_value.tv_sec = 0;
        val.it_value.tv_usec = 0;

        setitimer(ITIMER_REAL, &val, NULL);

        memset(&saction, 0, sizeof(saction));
        saction.sa_handler = NULL;

        sigaction(SIGALRM, &saction, NULL);
}


#ifdef TEST
static void timer_tick_test(struct timer *t, void *extra)
{
        printf((char *) extra); fflush(stdout);
}
#endif


/*
 *  timer_init():
 *
 *  Initialize the timer framework.
 */
void timer_init(void)
{
        first_timer = NULL;
        timer_current_time = 0.0;
        timer_is_running = 0;
        timer_countdown_to_next_gettimeofday = 0;

        timer_freq = TIMER_BASE_FREQUENCY;
        timer_current_time_step = 1.0 / timer_freq;

#ifdef TEST
        timer_add(0.5, timer_tick_test, "X");
        timer_add(10.0, timer_tick_test, ".");
        timer_add(200.0, timer_tick_test, " ");
        timer_start();
        while (1)
                sleep(999999);
#endif
}

1	/*
2	* Copyright (C) 2006-2007 Anders Gavare. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions are met:
6	*
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	* 3. The name of the author may not be used to endorse or promote products
13	* derived from this software without specific prior written permission.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25	* SUCH DAMAGE.
26	*
27	*
28	* $Id: timer.c,v 1.11 2007/06/18 04:23:19 debug Exp $
29	*
30	* Timer framework. This is used by emulated clocks.
31	*/
32
33	#include <stdio.h>
34	#include <stdlib.h>
35	#include <signal.h>
36	#include <string.h>
37	#include <unistd.h>
38	#include <sys/time.h>
39
40	#include "misc.h"
41	#include "timer.h"
42
43
44	/* #define TEST */
45
46
47	struct timer {
48	struct timer *next;
49
50	double freq;
51	void (timer_tick)(struct timer timer, void *extra);
52	void *extra;
53
54	double interval;
55	double next_tick_at;
56	};
57
58	static struct timer *first_timer = NULL;
59	struct timeval timer_start_tv;
60	static double timer_freq;
61	static int timer_countdown_to_next_gettimeofday;
62	static double timer_current_time;
63	static double timer_current_time_step;
64
65	static int timer_is_running;
66
67	#define SECONDS_BETWEEN_GETTIMEOFDAY_SYNCH 1.65
68
69
70	/*
71	* timer_add():
72	*
73	* Adds a virtual timer to the list of timers.
74	*
75	* Return value is a pointer to a timer struct.
76	*/
77	struct timer timer_add(double freq, void (timer_tick)(struct timer *timer,
78	void extra), void extra)
79	{
80	struct timer *newtimer;
81
82	CHECK_ALLOCATION(newtimer = malloc(sizeof(struct timer)));
83
84	if (freq <= 0.00000001)
85	freq = 0.00000001;
86
87	newtimer->freq = freq;
88	newtimer->timer_tick = timer_tick;
89	newtimer->extra = extra;
90
91	newtimer->interval = 1.0 / freq;
92	newtimer->next_tick_at = timer_current_time + newtimer->interval;
93
94	newtimer->next = first_timer;
95	first_timer = newtimer;
96
97	return newtimer;
98	}
99
100
101	/*
102	* timer_remove():
103	*
104	* Removes a virtual timer from the list of timers.
105	*/
106	void timer_remove(struct timer *t)
107	{
108	struct timer prev = NULL, cur = first_timer;
109
110	while (cur != NULL && cur != t) {
111	prev = cur;
112	cur = cur->next;
113	}
114
115	if (cur == t) {
116	if (prev == NULL)
117	first_timer = cur->next;
118	else
119	prev->next = cur->next;
120	free(cur);
121	} else {
122	fprintf(stderr, "attempt to remove timer %p which "
123	"doesn't exist. aborting\n", t);
124	exit(1);
125	}
126	}
127
128
129	/*
130	* timer_update_frequency():
131	*
132	* Changes the frequency of an existing timer.
133	*/
134	void timer_update_frequency(struct timer *t, double new_freq)
135	{
136	if (t->freq == new_freq)
137	return;
138
139	t->freq = new_freq;
140
141	if (new_freq <= 0.00000001)
142	new_freq = 0.00000001;
143
144	t->interval = 1.0 / new_freq;
145	t->next_tick_at = timer_current_time + t->interval;
146	}
147
148
149	/*
150	* timer_tick():
151	*
152	* Timer tick handler. This is where the interesting stuff happens.
153	*/
154	static void timer_tick(int signal_nr)
155	{
156	struct timer *timer = first_timer;
157	struct timeval tv;
158
159	timer_current_time += timer_current_time_step;
160
161	if ((--timer_countdown_to_next_gettimeofday) < 0) {
162	gettimeofday(&tv, NULL);
163	tv.tv_sec -= timer_start_tv.tv_sec;
164	tv.tv_usec -= timer_start_tv.tv_usec;
165	if (tv.tv_usec < 0) {
166	tv.tv_usec += 1000000;
167	tv.tv_sec --;
168	}
169
170	#ifdef TIMER_DEBUG
171	/* For debugging/testing: */
172	{
173	double diff = tv.tv_usec * 0.000001 + tv.tv_sec
174	- timer_current_time;
175	printf("timer: lagging behind %f seconds\n", diff);
176	}
177	#endif
178
179	/* Get exponentially closer to the real time, instead of
180	just changing to it directly: */
181	timer_current_time = ( (tv.tv_usec * 0.000001 + tv.tv_sec) +
182	timer_current_time ) / 2;
183
184	timer_countdown_to_next_gettimeofday = timer_freq *
185	SECONDS_BETWEEN_GETTIMEOFDAY_SYNCH;
186	}
187
188	while (timer != NULL) {
189	while (timer_current_time >= timer->next_tick_at) {
190	timer->timer_tick(timer, timer->extra);
191	timer->next_tick_at += timer->interval;
192	}
193
194	timer = timer->next;
195	}
196
197	#ifdef TEST
198	printf("T"); fflush(stdout);
199	#endif
200	}
201
202
203	/*
204	* timer_start():
205	*
206	* Set the interval timer to timer_freq Hz, and install the signal handler.
207	*/
208	void timer_start(void)
209	{
210	struct timer *timer = first_timer;
211	struct itimerval val;
212	struct sigaction saction;
213
214	if (timer_is_running)
215	return;
216
217	timer_is_running = 1;
218
219	gettimeofday(&timer_start_tv, NULL);
220	timer_current_time = 0.0;
221
222	/* Reset all timers: */
223	while (timer != NULL) {
224	timer->next_tick_at = timer->interval;
225	timer = timer->next;
226	}
227	val.it_interval.tv_sec = 0;
228	val.it_interval.tv_usec = 1000000.0 / timer_freq;
229	val.it_value.tv_sec = 0;
230	val.it_value.tv_usec = 1000000.0 / timer_freq;
231
232	memset(&saction, 0, sizeof(saction));
233	saction.sa_handler = timer_tick;
234
235	sigaction(SIGALRM, &saction, NULL);
236
237	setitimer(ITIMER_REAL, &val, NULL);
238	}
239
240
241	/*
242	* timer_stop():
243	*
244	* Deinstall the signal handler, and disable the interval timer.
245	*/
246	void timer_stop(void)
247	{
248	struct itimerval val;
249	struct sigaction saction;
250
251	if (!timer_is_running)
252	return;
253
254	timer_is_running = 0;
255
256	val.it_interval.tv_sec = 0;
257	val.it_interval.tv_usec = 0;
258	val.it_value.tv_sec = 0;
259	val.it_value.tv_usec = 0;
260
261	setitimer(ITIMER_REAL, &val, NULL);
262
263	memset(&saction, 0, sizeof(saction));
264	saction.sa_handler = NULL;
265
266	sigaction(SIGALRM, &saction, NULL);
267	}
268
269
270	#ifdef TEST
271	static void timer_tick_test(struct timer t, void extra)
272	{
273	printf((char *) extra); fflush(stdout);
274	}
275	#endif
276
277
278	/*
279	* timer_init():
280	*
281	* Initialize the timer framework.
282	*/
283	void timer_init(void)
284	{
285	first_timer = NULL;
286	timer_current_time = 0.0;
287	timer_is_running = 0;
288	timer_countdown_to_next_gettimeofday = 0;
289
290	timer_freq = TIMER_BASE_FREQUENCY;
291	timer_current_time_step = 1.0 / timer_freq;
292
293	#ifdef TEST
294	timer_add(0.5, timer_tick_test, "X");
295	timer_add(10.0, timer_tick_test, ".");
296	timer_add(200.0, timer_tick_test, " ");
297	timer_start();
298	while (1)
299	sleep(999999);
300	#endif
301	}
302