This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_systimer.c
229 lines (199 loc) · 6.9 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
20
21
Sam Lantinga
slouken@libsdl.org
*/
22
#include "SDL_config.h"
23
24
25
#ifdef SDL_TIMER_OS2
26
27
28
29
30
31
32
33
34
35
36
#define INCL_DOSMISC
#define INCL_DOSERRORS
#define INCL_DOSSEMAPHORES
#define INCL_DOSDATETIME
#define INCL_DOSPROCESS
#define INCL_DOSPROFILE
#define INCL_DOSEXCEPTIONS
#include <os2.h>
#include "SDL_thread.h"
#include "SDL_timer.h"
37
#include "../SDL_timer_c.h"
38
39
40
41
42
43
44
45
46
#define TIME_WRAP_VALUE (~(DWORD)0)
/* The first high-resolution ticks value of the application */
static long long hires_start_ticks;
/* The number of ticks per second of the high-resolution performance counter */
static ULONG hires_ticks_per_second;
47
void
48
SDL_StartTicks(void)
49
{
50
51
DosTmrQueryFreq(&hires_ticks_per_second);
DosTmrQueryTime((PQWORD) & hires_start_ticks);
52
53
}
54
DECLSPEC Uint32 SDLCALL
55
SDL_GetTicks(void)
56
{
57
58
long long hires_now;
ULONG ticks = ticks;
59
60
DosTmrQueryTime((PQWORD) & hires_now);
61
62
63
64
65
/*
hires_now -= hires_start_ticks;
hires_now *= 1000;
hires_now /= hires_ticks_per_second;
*/
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/* inline asm to avoid runtime inclusion */
_asm {
push edx
push eax
mov eax, dword ptr hires_now
mov edx, dword ptr hires_now + 4
sub eax, dword ptr hires_start_ticks
sbb edx, dword ptr hires_start_ticks + 4
mov ebx, 1000
mov ecx, edx
mul ebx
push eax
push edx
mov eax, ecx
mul ebx
pop eax
add edx, eax
pop eax
mov ebx, dword ptr hires_ticks_per_second
div ebx mov dword ptr ticks, eax pop edx pop eax}
return ticks;
88
89
90
91
}
/* High resolution sleep, originally made by Ilya Zakharevich */
92
DECLSPEC void SDLCALL
93
SDL_Delay(Uint32 ms)
94
{
95
96
97
98
99
100
101
102
103
104
105
106
107
/* This is similar to DosSleep(), but has 8ms granularity in time-critical
threads even on Warp3. */
HEV hevEvent1 = 0; /* Event semaphore handle */
HTIMER htimerEvent1 = 0; /* Timer handle */
APIRET rc = NO_ERROR; /* Return code */
int ret = 1;
ULONG priority = 0, nesting; /* Shut down the warnings */
PPIB pib;
PTIB tib;
char *e = NULL;
APIRET badrc;
int switch_priority = 50;
108
109
110
111
DosCreateEventSem(NULL, /* Unnamed */
&hevEvent1, /* Handle of semaphore returned */
DC_SEM_SHARED, /* Shared needed for DosAsyncTimer */
FALSE); /* Semaphore is in RESET state */
112
113
if (ms >= switch_priority)
114
switch_priority = 0;
115
if (switch_priority) {
116
if (DosGetInfoBlocks(&tib, &pib) != NO_ERROR)
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
switch_priority = 0;
else {
/* In Warp3, to switch scheduling to 8ms step, one needs to do
DosAsyncTimer() in time-critical thread. On laters versions,
more and more cases of wait-for-something are covered.
It turns out that on Warp3fp42 it is the priority at the time
of DosAsyncTimer() which matters. Let's hope that this works
with later versions too... XXXX
*/
priority = (tib->tib_ptib2->tib2_ulpri);
if ((priority & 0xFF00) == 0x0300) /* already time-critical */
switch_priority = 0;
/* Make us time-critical. Just modifying TIB is not enough... */
/* tib->tib_ptib2->tib2_ulpri = 0x0300; */
/* We do not want to run at high priority if a signal causes us
to longjmp() out of this section... */
134
if (DosEnterMustComplete(&nesting))
135
136
switch_priority = 0;
else
137
DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
138
139
140
}
}
141
142
if ((badrc = DosAsyncTimer(ms, (HSEM) hevEvent1, /* Semaphore to post */
&htimerEvent1))) /* Timer handler (returned) */
143
144
145
146
147
148
e = "DosAsyncTimer";
if (switch_priority && tib->tib_ptib2->tib2_ulpri == 0x0300) {
/* Nobody switched priority while we slept... Ignore errors... */
/* tib->tib_ptib2->tib2_ulpri = priority; *//* Get back... */
if (!
149
150
(rc = DosSetPriority(PRTYS_THREAD, (priority >> 8) & 0xFF, 0, 0)))
rc = DosSetPriority(PRTYS_THREAD, 0, priority & 0xFF, 0);
151
152
}
if (switch_priority)
153
rc = DosExitMustComplete(&nesting); /* Ignore errors */
154
155
156
157
158
159
/* The actual blocking call is made with "normal" priority. This way we
should not bother with DosSleep(0) etc. to compensate for us interrupting
higher-priority threads. The goal is to prohibit the system spending too
much time halt()ing, not to run us "no matter what". */
if (!e) /* Wait for AsyncTimer event */
160
badrc = DosWaitEventSem(hevEvent1, SEM_INDEFINITE_WAIT);
161
162
163
164
165
166
if (e); /* Do nothing */
else if (badrc == ERROR_INTERRUPT)
ret = 0;
else if (badrc)
e = "DosWaitEventSem";
167
if ((rc = DosCloseEventSem(hevEvent1)) && !e) { /* Get rid of semaphore */
168
169
170
171
e = "DosCloseEventSem";
badrc = rc;
}
if (e) {
172
173
SDL_SetError("[SDL_Delay] : Had error in %s(), rc is 0x%x\n", e,
badrc);
174
175
176
177
178
179
180
}
}
/* Data to handle a single periodic alarm */
static int timer_alive = 0;
static SDL_Thread *timer = NULL;
181
static int
182
RunTimer(void *unused)
183
{
184
DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
185
186
while (timer_alive) {
if (SDL_timer_running) {
187
SDL_ThreadedTimerCheck();
188
}
189
SDL_Delay(10);
190
191
}
return (0);
192
193
194
}
/* This is only called if the event thread is not running */
195
int
196
SDL_SYS_TimerInit(void)
197
{
198
timer_alive = 1;
199
timer = SDL_CreateThread(RunTimer, NULL);
200
201
if (timer == NULL)
return (-1);
202
return (SDL_SetTimerThreaded(1));
203
204
}
205
void
206
SDL_SYS_TimerQuit(void)
207
{
208
209
timer_alive = 0;
if (timer) {
210
SDL_WaitThread(timer, NULL);
211
212
timer = NULL;
}
213
214
}
215
int
216
SDL_SYS_StartTimer(void)
217
{
218
SDL_SetError("Internal logic error: OS/2 uses threaded timer");
219
return (-1);
220
221
}
222
void
223
SDL_SYS_StopTimer(void)
224
{
225
return;
226
227
}
228
#endif /* SDL_TIMER_OS2 */
229
/* vi: set ts=4 sw=4 expandtab: */