/
SDL_systimer.c
341 lines (292 loc) · 7.8 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
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
13
Lesser General Public License for more details.
14
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
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
*/
#include <stdio.h>
#include <sys/time.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
32
33
34
35
36
/* 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
*/
37
#if (defined _POSIX_TIMERS && _POSIX_TIMERS + 0 > 0)
38
#include <time.h>
39
40
41
42
43
44
45
/*
* 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*/
46
47
#endif
48
49
50
51
#include "SDL_error.h"
#include "SDL_timer.h"
#include "SDL_timer_c.h"
52
53
54
#if _POSIX_THREAD_SYSCALL_SOFT
#include <pthread.h>
#endif
55
56
57
#ifdef ENABLE_PTH
#include <pth.h>
#endif
58
59
60
61
62
63
64
#if defined(DISABLE_THREADS) || defined(FORK_HACK)
#define USE_ITIMER
#endif
/* The following defines should really be determined at configure time */
65
#if defined(linux)
66
67
68
/* 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
69
#elif defined(__bsdi__) || defined(__FreeBSD__) || defined(__sun) || defined(MACOSX)
70
71
72
#define USE_NANOSLEEP
#endif
73
#if defined(i386) || defined(__i386__)
74
/* This only works on pentium or newer x86 processors */
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
/* 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.
*/
90
#define rdtsc(t) asm __volatile__ (".byte 0x0f, 0x31; " : "=A" (t))
91
#else
92
#define rdtsc(t) asm __volatile__ ("rdtsc" : "=A" (t))
93
94
95
96
97
98
99
#endif
static float calc_cpu_mhz(void)
{
float cpu_mhz;
unsigned long long tsc_start;
unsigned long long tsc_end;
100
101
102
103
104
105
106
107
108
109
110
111
112
/* 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
113
114
115
116
117
118
119
120
121
122
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);
123
#endif /* USE_CLOCK_GETTIME */
124
125
126
127
128
129
130
131
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
132
133
/* The first ticks value of the application */
134
135
136
#ifdef USE_CLOCK_GETTIME
static struct timespec start;
#else
137
static struct timeval start;
138
#endif /* USE_CLOCK_GETTIME */
139
140
141
142
#endif /* USE_RDTSC */
143
144
145
void SDL_StartTicks(void)
{
/* Set first ticks value */
146
147
148
149
150
#ifdef USE_RDTSC
if ( ! cpu_mhz1000 ) {
cpu_mhz1000 = calc_cpu_mhz() * 1000.0f;
}
rdtsc(start);
151
152
#elif defined(USE_CLOCK_GETTIME)
clock_gettime(CLOCK_MONOTONIC,&start);
153
#else
154
gettimeofday(&start, NULL);
155
#endif
156
157
158
159
}
Uint32 SDL_GetTicks (void)
{
160
161
162
163
164
165
166
#ifdef USE_RDTSC
unsigned long long now;
if ( ! cpu_mhz1000 ) {
return 0; /* Shouldn't happen. BUG!! */
}
rdtsc(now);
return (Uint32)((now-start)/cpu_mhz1000);
167
168
169
170
171
172
#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);
173
#else
174
Uint32 ticks;
175
struct timeval now;
176
177
178
gettimeofday(&now, NULL);
ticks=(now.tv_sec-start.tv_sec)*1000+(now.tv_usec-start.tv_usec)/1000;
return(ticks);
179
#endif
180
181
182
183
}
void SDL_Delay (Uint32 ms)
{
184
185
186
187
188
189
#ifdef ENABLE_PTH
pth_time_t tv;
tv.tv_sec = ms/1000;
tv.tv_usec = (ms%1000)*1000;
pth_nap(tv);
#else
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
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;
214
215
216
#if _POSIX_THREAD_SYSCALL_SOFT
pthread_yield_np();
#endif
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
#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) );
237
#endif /* ENABLE_PTH */
238
239
240
241
242
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
}
#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 */