osapi/posix/systimer.cc

/// @file systimer.cc
/// @author Kimball Thurston
///

//
// Copyright (c) 2004 Kimball Thurston
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or 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 this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//

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

#include "system/systimer.h"
#include "tools/snprintf.h"

static const int kTimerSignal = SYSTIMER_SIGNAL;
#ifdef USE_POSIX_REALTIME_CLOCK
static void signal_handler(int signo, siginfo_t *extra, void *junk);
static const int kClockRT = CLOCK_PROCESS_CPUTIME_ID;
static const int kClock = CLOCK_REALTIME;
#elif USE_POSIX_SETITIMER
static void signal_handler(int signo);
static const int kClock = ITIMER_REAL;
struct sys_timer_struct;
static sys_timer_struct *gSingleTimer = NULL;
static const int kSignalFlags = 0;
#else
#error no timer support
#endif

struct sys_timer_struct
{
#ifdef USE_POSIX_REALTIME_CLOCK
        struct sigevent event_info;
        timer_t timer_id;
#endif
        sys_timer_callback callback;
        int clock;
        uint64 timer_res;

        sys_timer_struct(sys_timer_callback cb)
                        : callback(cb), clock(kClock), timer_res(0)
        {
#ifdef USE_POSIX_REALTIME_CLOCK
                memset(&event_info, 0, sizeof event_info);
                timer_id = 0;

                event_info.sigev_notify = SIGEV_SIGNAL;
                event_info.sigev_signo = kTimerSignal;
                event_info.sigev_value.sival_ptr = this;
#endif
        }
};

#ifdef USE_POSIX_REALTIME_CLOCK
static void signal_handler(int signo, siginfo_t *extra, void *junk)
{
        sys_timer_struct *timer = reinterpret_cast<sys_timer_struct *>(extra->si_value.sival_ptr);
        timer->callback(reinterpret_cast<sys_timer>(timer));
}
#else
# ifdef USE_POSIX_SETITIMER
static void signal_handler(int signo)
{
        if (gSingleTimer != NULL) {
                gSingleTimer->callback(reinterpret_cast<sys_timer>(gSingleTimer));
        }
}
# endif
#endif

bool sys_create_timer(sys_timer *t, sys_timer_callback cb_func)
{
        *t = 0;

        sys_timer_struct *newTimer = new sys_timer_struct(cb_func);

#ifdef USE_POSIX_REALTIME_CLOCK
        int clocks[] = {kClockRT, kClock};

        struct timespec clockRes;
        bool foundTimer = false;

        for (uint i=0; i < (sizeof clocks / sizeof clocks[0]); i++) {
                if (clock_getres(clocks[i], &clockRes) == 0
                 && timer_create(clocks[i], &newTimer->event_info,
                                         &newTimer->timer_id) == 0) {

                        newTimer->clock = clocks[i];
                        foundTimer = true;
                        break;
                }
        }
        
        if (!foundTimer) {
                perror("Timer create error");
                delete newTimer;
                return false;
        }

        newTimer->timer_res = (uint64)clockRes.tv_sec * 1000 * 1000 * 1000;
        newTimer->timer_res += (uint64)clockRes.tv_nsec;
#else
# ifdef USE_POSIX_SETITIMER
        if (gSingleTimer != NULL) {
                ht_printf("There can only be one active sys timer at a time using\n"
                                  "interval timers.\n");
                delete newTimer;
                return false;
        }
        newTimer->timer_res = 10 * 1000 * 1000;
# endif
#endif

        struct sigaction act;

        sigemptyset(&act.sa_mask);
#ifdef USE_POSIX_REALTIME_CLOCK
        act.sa_sigaction = signal_handler;
        act.sa_flags = SA_SIGINFO;
#else
# ifdef USE_POSIX_SETITIMER
        act.sa_handler = signal_handler;
        act.sa_flags = 0;
# endif
#endif

        if (sigemptyset(&act.sa_mask) == -1) {
                perror("Error calling sigemptyset");
                return false;
        }

        if (sigaction(kTimerSignal, &act, 0) == -1) {
                perror("Error calling sigaction");
                return false;
        }

        *t = reinterpret_cast<sys_timer>(newTimer);
#ifdef USE_POSIX_SETITIMER
        gSingleTimer = newTimer;
#endif

        return true;
}

void sys_delete_timer(sys_timer t)
{
        sys_timer_struct *timer = reinterpret_cast<sys_timer_struct *>(t);

#ifdef USE_POSIX_REALTIME_CLOCK
        timer_delete(timer->timer_id);
#else
# ifdef USE_POSIX_SETITIMER
        struct itimerval itime;

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

        setitimer(timer->clock, &itime, NULL);
        gSingleTimer = NULL;
# endif
#endif

        delete timer;
}

void sys_set_timer(sys_timer t, time_t secs, long int nanosecs, bool periodic)
{
        sys_timer_struct *timer = reinterpret_cast<sys_timer_struct *>(t);
#ifdef USE_POSIX_REALTIME_CLOCK
        struct itimerspec itime;

        itime.it_value.tv_sec = secs;
        // FIXME: Do we need to have rounding based on timer resolution here?
        itime.it_value.tv_nsec = nanosecs;// + (nanosecs % timer->timer_res);

        if (periodic) {
                itime.it_interval.tv_sec = secs;
                itime.it_interval.tv_nsec = nanosecs;
        } else {
                itime.it_interval.tv_sec = 0;
                itime.it_interval.tv_nsec = 0;
        }

        if (timer_settime(timer->timer_id, 0, &itime, NULL) < 0) {
                perror(__FUNCTION__);
        }
        
#else
# ifdef USE_POSIX_SETITIMER
        struct itimerval itime;

        itime.it_value.tv_sec = secs;
        itime.it_value.tv_usec = (nanosecs + 500) / 1000;

        if (periodic) {
                itime.it_interval = itime.it_value;
        } else {
                itime.it_interval.tv_sec = 0;
                itime.it_interval.tv_usec = 0;
        }

        setitimer(timer->clock, &itime, NULL);
# endif
#endif
}

uint64 sys_get_timer_resolution(sys_timer t)
{
        sys_timer_struct *timer = reinterpret_cast<sys_timer_struct *>(t);
        return timer->timer_res;
}

uint64 sys_get_hiresclk_ticks()
{
#if HAVE_GETTIMEOFDAY
       struct timeval tv;
       struct timezone tz;

       gettimeofday(&tv, &tz);
       //__asm__ __volatile__("rdtsc" : "=A" (retval));

       return ((uint64)tv.tv_sec * 1000000) + tv.tv_usec;
#else
        return clock();
#endif
}

uint64 sys_get_hiresclk_ticks_per_second()
{
#if HAVE_GETTIMEOFDAY
       return 1000000;
#else
        return clock();
#endif
}
1	dpavlin	1	/// @file systimer.cc
2			/// @author Kimball Thurston
3			///
4
5			//
6			// Copyright (c) 2004 Kimball Thurston
7			//
8			// This program is free software; you can redistribute it and/or modify
9			// it under the terms of the GNU General Public License version 2 as
10			// published by the Free Software Foundation.
11			//
12			// This program is distributed in the hope that it will be useful,
13			// but WITHOUT ANY WARRANTY; without even the implied warranty of
14			// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			// GNU General Public License for more details.
16			//
17			// You should have received a copy of the GNU General Public License
18			// along with this program; if not, write to the Free Software
19			// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20			//
21
22			#include <signal.h>
23			#include <time.h>
24			#include <stdio.h>
25			#include <string.h>
26			#include <sys/time.h>
27
28			#include "system/systimer.h"
29			#include "tools/snprintf.h"
30
31			static const int kTimerSignal = SYSTIMER_SIGNAL;
32			#ifdef USE_POSIX_REALTIME_CLOCK
33			static void signal_handler(int signo, siginfo_t extra, void junk);
34			static const int kClockRT = CLOCK_PROCESS_CPUTIME_ID;
35			static const int kClock = CLOCK_REALTIME;
36			#elif USE_POSIX_SETITIMER
37			static void signal_handler(int signo);
38			static const int kClock = ITIMER_REAL;
39			struct sys_timer_struct;
40			static sys_timer_struct *gSingleTimer = NULL;
41			static const int kSignalFlags = 0;
42			#else
43			#error no timer support
44			#endif
45
46			struct sys_timer_struct
47			{
48			#ifdef USE_POSIX_REALTIME_CLOCK
49			struct sigevent event_info;
50			timer_t timer_id;
51			#endif
52			sys_timer_callback callback;
53			int clock;
54			uint64 timer_res;
55
56			sys_timer_struct(sys_timer_callback cb)
57			: callback(cb), clock(kClock), timer_res(0)
58			{
59			#ifdef USE_POSIX_REALTIME_CLOCK
60			memset(&event_info, 0, sizeof event_info);
61			timer_id = 0;
62
63			event_info.sigev_notify = SIGEV_SIGNAL;
64			event_info.sigev_signo = kTimerSignal;
65			event_info.sigev_value.sival_ptr = this;
66			#endif
67			}
68			};
69
70			#ifdef USE_POSIX_REALTIME_CLOCK
71			static void signal_handler(int signo, siginfo_t extra, void junk)
72			{
73			sys_timer_struct timer = reinterpret_cast<sys_timer_struct >(extra->si_value.sival_ptr);
74			timer->callback(reinterpret_cast<sys_timer>(timer));
75			}
76			#else
77			# ifdef USE_POSIX_SETITIMER
78			static void signal_handler(int signo)
79			{
80			if (gSingleTimer != NULL) {
81			gSingleTimer->callback(reinterpret_cast<sys_timer>(gSingleTimer));
82			}
83			}
84			# endif
85			#endif
86
87			bool sys_create_timer(sys_timer *t, sys_timer_callback cb_func)
88			{
89			*t = 0;
90
91			sys_timer_struct *newTimer = new sys_timer_struct(cb_func);
92
93			#ifdef USE_POSIX_REALTIME_CLOCK
94			int clocks[] = {kClockRT, kClock};
95
96			struct timespec clockRes;
97			bool foundTimer = false;
98
99			for (uint i=0; i < (sizeof clocks / sizeof clocks[0]); i++) {
100			if (clock_getres(clocks[i], &clockRes) == 0
101			&& timer_create(clocks[i], &newTimer->event_info,
102			&newTimer->timer_id) == 0) {
103
104			newTimer->clock = clocks[i];
105			foundTimer = true;
106			break;
107			}
108			}
109
110			if (!foundTimer) {
111			perror("Timer create error");
112			delete newTimer;
113			return false;
114			}
115
116			newTimer->timer_res = (uint64)clockRes.tv_sec * 1000 * 1000 * 1000;
117			newTimer->timer_res += (uint64)clockRes.tv_nsec;
118			#else
119			# ifdef USE_POSIX_SETITIMER
120			if (gSingleTimer != NULL) {
121			ht_printf("There can only be one active sys timer at a time using\n"
122			"interval timers.\n");
123			delete newTimer;
124			return false;
125			}
126			newTimer->timer_res = 10 * 1000 * 1000;
127			# endif
128			#endif
129
130			struct sigaction act;
131
132			sigemptyset(&act.sa_mask);
133			#ifdef USE_POSIX_REALTIME_CLOCK
134			act.sa_sigaction = signal_handler;
135			act.sa_flags = SA_SIGINFO;
136			#else
137			# ifdef USE_POSIX_SETITIMER
138			act.sa_handler = signal_handler;
139			act.sa_flags = 0;
140			# endif
141			#endif
142
143			if (sigemptyset(&act.sa_mask) == -1) {
144			perror("Error calling sigemptyset");
145			return false;
146			}
147
148			if (sigaction(kTimerSignal, &act, 0) == -1) {
149			perror("Error calling sigaction");
150			return false;
151			}
152
153			*t = reinterpret_cast<sys_timer>(newTimer);
154			#ifdef USE_POSIX_SETITIMER
155			gSingleTimer = newTimer;
156			#endif
157
158			return true;
159			}
160
161			void sys_delete_timer(sys_timer t)
162			{
163			sys_timer_struct timer = reinterpret_cast<sys_timer_struct >(t);
164
165			#ifdef USE_POSIX_REALTIME_CLOCK
166			timer_delete(timer->timer_id);
167			#else
168			# ifdef USE_POSIX_SETITIMER
169			struct itimerval itime;
170
171			itime.it_value.tv_sec = 0;
172			itime.it_value.tv_usec = 0;
173			itime.it_interval.tv_sec = 0;
174			itime.it_interval.tv_usec = 0;
175
176			setitimer(timer->clock, &itime, NULL);
177			gSingleTimer = NULL;
178			# endif
179			#endif
180
181			delete timer;
182			}
183
184			void sys_set_timer(sys_timer t, time_t secs, long int nanosecs, bool periodic)
185			{
186			sys_timer_struct timer = reinterpret_cast<sys_timer_struct >(t);
187			#ifdef USE_POSIX_REALTIME_CLOCK
188			struct itimerspec itime;
189
190			itime.it_value.tv_sec = secs;
191			// FIXME: Do we need to have rounding based on timer resolution here?
192			itime.it_value.tv_nsec = nanosecs;// + (nanosecs % timer->timer_res);
193
194			if (periodic) {
195			itime.it_interval.tv_sec = secs;
196			itime.it_interval.tv_nsec = nanosecs;
197			} else {
198			itime.it_interval.tv_sec = 0;
199			itime.it_interval.tv_nsec = 0;
200			}
201
202			if (timer_settime(timer->timer_id, 0, &itime, NULL) < 0) {
203			perror(__FUNCTION__);
204			}
205
206			#else
207			# ifdef USE_POSIX_SETITIMER
208			struct itimerval itime;
209
210			itime.it_value.tv_sec = secs;
211			itime.it_value.tv_usec = (nanosecs + 500) / 1000;
212
213			if (periodic) {
214			itime.it_interval = itime.it_value;
215			} else {
216			itime.it_interval.tv_sec = 0;
217			itime.it_interval.tv_usec = 0;
218			}
219
220			setitimer(timer->clock, &itime, NULL);
221			# endif
222			#endif
223			}
224
225			uint64 sys_get_timer_resolution(sys_timer t)
226			{
227			sys_timer_struct timer = reinterpret_cast<sys_timer_struct >(t);
228			return timer->timer_res;
229			}
230
231			uint64 sys_get_hiresclk_ticks()
232			{
233			#if HAVE_GETTIMEOFDAY
234			struct timeval tv;
235			struct timezone tz;
236
237			gettimeofday(&tv, &tz);
238			//__asm__ __volatile__("rdtsc" : "=A" (retval));
239
240			return ((uint64)tv.tv_sec * 1000000) + tv.tv_usec;
241			#else
242			return clock();
243			#endif
244			}
245
246			uint64 sys_get_hiresclk_ticks_per_second()
247			{
248			#if HAVE_GETTIMEOFDAY
249			return 1000000;
250			#else
251			return clock();
252			#endif
253			}