/
SDL_systimer.c
346 lines (296 loc) · 7.85 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2004 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
20
slouken@libsdl.org
21
22
RDTSC stuff by lompik (lompik@voila.fr) 20/03/2002
23
24
25
26
27
28
29
30
31
32
33
34
35
36
*/
#ifdef SAVE_RCSID
static char rcsid =
"@(#) $Id$";
#endif
#include <stdio.h>
#include <sys/time.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
37
38
39
40
41
42
43
/* The clock_gettime provides monotonous time, so we should use it if
it's available. The clock_gettime function is behind ifdef
for __USE_POSIX199309
Tommi Kyntola (tommi.kyntola@ray.fi) 27/09/2005
*/
#if (defined _POSIX_TIMERS && _POSIX_TIMERS > 0)
#include <time.h>
44
45
46
47
48
49
50
/*
* clock_gettime() is missing in my system's glibc, and apparently isn't
* available before Linux kernel 2.6...you can uncomment the following
* define to use it, since it may be a better solution than
* gettimeofday() on systems that support the newer syscall. --ryan.
*/
/*#define USE_CLOCK_GETTIME*/
51
52
#endif
53
54
55
56
#include "SDL_error.h"
#include "SDL_timer.h"
#include "SDL_timer_c.h"
57
58
59
#if _POSIX_THREAD_SYSCALL_SOFT
#include <pthread.h>
#endif
60
61
62
#ifdef ENABLE_PTH
#include <pth.h>
#endif
63
64
65
66
67
68
69
#if defined(DISABLE_THREADS) || defined(FORK_HACK)
#define USE_ITIMER
#endif
/* The following defines should really be determined at configure time */
70
#if defined(linux)
71
72
73
/* Linux select() changes its timeout parameter upon return to contain
the remaining time. Most other unixen leave it unchanged or undefined. */
#define SELECT_SETS_REMAINING
74
#elif defined(__bsdi__) || defined(__FreeBSD__) || defined(__sun) || defined(MACOSX)
75
76
77
#define USE_NANOSLEEP
#endif
78
#if defined(i386) || defined(__i386__)
79
/* This only works on pentium or newer x86 processors */
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
/* Actually, this isn't reliable on multi-cpu systems, so is disabled */
/*#define USE_RDTSC*/
#endif
#ifdef USE_RDTSC
/* The first ticks value of the application */
static unsigned long long start;
static float cpu_mhz1000 = 0.0f;
#if 1
/* This is for old binutils version that don't recognize rdtsc mnemonics.
But all binutils version supports this.
*/
95
#define rdtsc(t) asm __volatile__ (".byte 0x0f, 0x31; " : "=A" (t))
96
#else
97
#define rdtsc(t) asm __volatile__ ("rdtsc" : "=A" (t))
98
99
100
101
102
103
104
#endif
static float calc_cpu_mhz(void)
{
float cpu_mhz;
unsigned long long tsc_start;
unsigned long long tsc_end;
105
106
107
108
109
110
111
112
113
114
115
116
117
/* Slight code doubling here for the sake of readability */
#ifdef USE_CLOCK_GETTIME
struct timespec tv_start, tv_end;
long usec_delay;
rdtsc(tsc_start);
clock_gettime(CLOCK_MONOTONIC,&tv_start);
sleep(1);
rdtsc(tsc_end);
clock_gettime(CLOCK_MONOTONIC,&tv_end);
usec_delay = (1000000000L * (tv_end.tv_sec - tv_start.tv_sec) +
(tv_end.tv_nsec - tv_start.tv_nsec)) / 1000;
#else
118
119
120
121
122
123
124
125
126
127
struct timeval tv_start, tv_end;
long usec_delay;
rdtsc(tsc_start);
gettimeofday(&tv_start, NULL);
sleep(1);
rdtsc(tsc_end);
gettimeofday(&tv_end, NULL);
usec_delay = 1000000L * (tv_end.tv_sec - tv_start.tv_sec) +
(tv_end.tv_usec - tv_start.tv_usec);
128
#endif /* USE_CLOCK_GETTIME */
129
130
131
132
133
134
135
136
cpu_mhz = (float)(tsc_end-tsc_start) / usec_delay;
#if 0
printf("cpu MHz\t\t: %.3f\n", cpu_mhz);
#endif
return cpu_mhz;
}
#else
137
138
/* The first ticks value of the application */
139
140
141
#ifdef USE_CLOCK_GETTIME
static struct timespec start;
#else
142
static struct timeval start;
143
#endif /* USE_CLOCK_GETTIME */
144
145
146
147
#endif /* USE_RDTSC */
148
149
150
void SDL_StartTicks(void)
{
/* Set first ticks value */
151
152
153
154
155
#ifdef USE_RDTSC
if ( ! cpu_mhz1000 ) {
cpu_mhz1000 = calc_cpu_mhz() * 1000.0f;
}
rdtsc(start);
156
157
#elif defined(USE_CLOCK_GETTIME)
clock_gettime(CLOCK_MONOTONIC,&start);
158
#else
159
gettimeofday(&start, NULL);
160
#endif
161
162
163
164
}
Uint32 SDL_GetTicks (void)
{
165
166
167
168
169
170
171
#ifdef USE_RDTSC
unsigned long long now;
if ( ! cpu_mhz1000 ) {
return 0; /* Shouldn't happen. BUG!! */
}
rdtsc(now);
return (Uint32)((now-start)/cpu_mhz1000);
172
173
174
175
176
177
#elif defined(USE_CLOCK_GETTIME)
Uint32 ticks;
struct timespec now;
clock_gettime(CLOCK_MONOTONIC,&now);
ticks=(now.tv_sec-start.tv_sec)*1000+(now.tv_nsec-start.tv_nsec)/1000000;
return(ticks);
178
#else
179
Uint32 ticks;
180
struct timeval now;
181
182
183
gettimeofday(&now, NULL);
ticks=(now.tv_sec-start.tv_sec)*1000+(now.tv_usec-start.tv_usec)/1000;
return(ticks);
184
#endif
185
186
187
188
}
void SDL_Delay (Uint32 ms)
{
189
190
191
192
193
194
#ifdef ENABLE_PTH
pth_time_t tv;
tv.tv_sec = ms/1000;
tv.tv_usec = (ms%1000)*1000;
pth_nap(tv);
#else
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
int was_error;
#ifdef USE_NANOSLEEP
struct timespec elapsed, tv;
#else
struct timeval tv;
#ifndef SELECT_SETS_REMAINING
Uint32 then, now, elapsed;
#endif
#endif
/* Set the timeout interval - Linux only needs to do this once */
#ifdef SELECT_SETS_REMAINING
tv.tv_sec = ms/1000;
tv.tv_usec = (ms%1000)*1000;
#elif defined(USE_NANOSLEEP)
elapsed.tv_sec = ms/1000;
elapsed.tv_nsec = (ms%1000)*1000000;
#else
then = SDL_GetTicks();
#endif
do {
errno = 0;
219
220
221
#if _POSIX_THREAD_SYSCALL_SOFT
pthread_yield_np();
#endif
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
#ifdef USE_NANOSLEEP
tv.tv_sec = elapsed.tv_sec;
tv.tv_nsec = elapsed.tv_nsec;
was_error = nanosleep(&tv, &elapsed);
#else
#ifndef SELECT_SETS_REMAINING
/* Calculate the time interval left (in case of interrupt) */
now = SDL_GetTicks();
elapsed = (now-then);
then = now;
if ( elapsed >= ms ) {
break;
}
ms -= elapsed;
tv.tv_sec = ms/1000;
tv.tv_usec = (ms%1000)*1000;
#endif
was_error = select(0, NULL, NULL, NULL, &tv);
#endif /* USE_NANOSLEEP */
} while ( was_error && (errno == EINTR) );
242
#endif /* ENABLE_PTH */
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
}
#ifdef USE_ITIMER
static void HandleAlarm(int sig)
{
Uint32 ms;
if ( SDL_alarm_callback ) {
ms = (*SDL_alarm_callback)(SDL_alarm_interval);
if ( ms != SDL_alarm_interval ) {
SDL_SetTimer(ms, SDL_alarm_callback);
}
}
}
int SDL_SYS_TimerInit(void)
{
struct sigaction action;
/* Set the alarm handler (Linux specific) */
memset(&action, 0, sizeof(action));
action.sa_handler = HandleAlarm;
action.sa_flags = SA_RESTART;
sigemptyset(&action.sa_mask);
sigaction(SIGALRM, &action, NULL);
return(0);
}
void SDL_SYS_TimerQuit(void)
{
SDL_SetTimer(0, NULL);
}
int SDL_SYS_StartTimer(void)
{
struct itimerval timer;
timer.it_value.tv_sec = (SDL_alarm_interval/1000);
timer.it_value.tv_usec = (SDL_alarm_interval%1000)*1000;
timer.it_interval.tv_sec = (SDL_alarm_interval/1000);
timer.it_interval.tv_usec = (SDL_alarm_interval%1000)*1000;
setitimer(ITIMER_REAL, &timer, NULL);
return(0);
}
void SDL_SYS_StopTimer(void)
{
struct itimerval timer;
memset(&timer, 0, (sizeof timer));
setitimer(ITIMER_REAL, &timer, NULL);
}
#else /* USE_ITIMER */
#include "SDL_thread.h"
/* Data to handle a single periodic alarm */
static int timer_alive = 0;
static SDL_Thread *timer = NULL;
static int RunTimer(void *unused)
{
while ( timer_alive ) {
if ( SDL_timer_running ) {
SDL_ThreadedTimerCheck();
}
SDL_Delay(1);
}
return(0);
}
/* This is only called if the event thread is not running */
int SDL_SYS_TimerInit(void)
{
timer_alive = 1;
timer = SDL_CreateThread(RunTimer, NULL);
if ( timer == NULL )
return(-1);
return(SDL_SetTimerThreaded(1));
}
void SDL_SYS_TimerQuit(void)
{
timer_alive = 0;
if ( timer ) {
SDL_WaitThread(timer, NULL);
timer = NULL;
}
}
int SDL_SYS_StartTimer(void)
{
SDL_SetError("Internal logic error: Linux uses threaded timer");
return(-1);
}
void SDL_SYS_StopTimer(void)
{
return;
}
#endif /* USE_ITIMER */