8600c0a99cd31061c3db4ab5a66e6d284189120c
[ghc.git] / rts / posix / Itimer.c
1 /* -----------------------------------------------------------------------------
2 *
3 * (c) The GHC Team, 1995-1999
4 *
5 * Interval timer for profiling and pre-emptive scheduling.
6 *
7 * ---------------------------------------------------------------------------*/
8
9 /*
10 * The interval timer is used for profiling and for context switching in the
11 * threaded build. Though POSIX 1003.1b includes a standard interface for
12 * such things, no one really seems to be implementing them yet. Even
13 * Solaris 2.3 only seems to provide support for @CLOCK_REAL@, whereas we're
14 * keen on getting access to @CLOCK_VIRTUAL@.
15 *
16 * Hence, we use the old-fashioned @setitimer@ that just about everyone seems
17 * to support. So much for standards.
18 */
19 #include "Rts.h"
20 #include "RtsFlags.h"
21 #include "Timer.h"
22 #include "Ticker.h"
23 #include "posix/Itimer.h"
24 #include "Proftimer.h"
25 #include "Storage.h"
26 #include "Schedule.h"
27 #include "posix/Select.h"
28
29 /* As recommended in the autoconf manual */
30 # ifdef TIME_WITH_SYS_TIME
31 # include <sys/time.h>
32 # include <time.h>
33 # else
34 # ifdef HAVE_SYS_TIME_H
35 # include <sys/time.h>
36 # else
37 # include <time.h>
38 # endif
39 # endif
40
41 #ifdef HAVE_SIGNAL_H
42 # include <signal.h>
43 #endif
44
45 /* Major bogosity:
46 *
47 * In the threaded RTS, we can't set the virtual timer because the
48 * thread which has the virtual timer might be sitting waiting for a
49 * capability, and the virtual timer only ticks in CPU time.
50 *
51 * So, possible solutions:
52 *
53 * (1) tick in realtime. Not very good, because this ticker is used for
54 * profiling, and this will give us unreliable time profiling
55 * results.
56 *
57 * (2) save/restore the virtual timer around excursions into STG land.
58 * Sounds great, but I tried it and the resolution of the virtual timer
59 * isn't good enough (on Linux) - most of our excursions fall
60 * within the timer's resolution and we never make any progress.
61 *
62 * (3) have a virtual timer in every OS thread. Might be reasonable,
63 * because most of the time there is only ever one of these
64 * threads running, so it approximates a single virtual timer.
65 * But still quite bogus (and I got crashes when I tried this).
66 *
67 * For now, we're using (1), but this needs a better solution. --SDM
68 */
69
70 #if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME)
71
72 # define USE_TIMER_CREATE
73 # define ITIMER_SIGNAL SIGVTALRM
74 # ifdef THREADED_RTS
75 # define TIMER_FLAVOUR CLOCK_REALTIME
76 # else
77 # define TIMER_FLAVOUR CLOCK_PROCESS_CPUTIME_ID
78 # endif
79
80 #elif defined(HAVE_SETITIMER)
81
82 # define USE_ITIMER
83 # ifdef THREADED_RTS
84 // Oh dear, we have to use SIGALRM if there's no timer_create and
85 // we're using the THREADED_RTS. This leads to problems, see bug #850.
86 # define ITIMER_SIGNAL SIGALRM
87 # define ITIMER_FLAVOUR ITIMER_REAL
88 # else
89 # define ITIMER_SIGNAL SIGVTALRM
90 # define ITIMER_FLAVOUR ITIMER_VIRTUAL
91 # endif
92
93 #else
94
95 # error No way to set an interval timer.
96
97 #endif
98
99 #if defined(USE_TIMER_CREATE)
100 timer_t timer;
101 #endif
102
103 static
104 void
105 install_vtalrm_handler(TickProc handle_tick)
106 {
107 struct sigaction action;
108
109 action.sa_handler = handle_tick;
110
111 sigemptyset(&action.sa_mask);
112
113 #ifdef SA_RESTART
114 // specify SA_RESTART. One consequence if we don't do this is
115 // that readline gets confused by the -threaded RTS. It seems
116 // that if a SIGALRM handler is installed without SA_RESTART,
117 // readline installs its own SIGALRM signal handler (see
118 // readline's signals.c), and this somehow causes readline to go
119 // wrong when the input exceeds a single line (try it).
120 action.sa_flags = SA_RESTART;
121 #else
122 action.sa_flags = 0;
123 #endif
124
125 if (sigaction(ITIMER_SIGNAL, &action, NULL) == -1) {
126 sysErrorBelch("sigaction");
127 stg_exit(EXIT_FAILURE);
128 }
129 }
130
131 void
132 startTicker(nat ms, TickProc handle_tick)
133 {
134 install_vtalrm_handler(handle_tick);
135
136 #if !defined(THREADED_RTS)
137 timestamp = getourtimeofday();
138 #endif
139
140 #if defined(USE_TIMER_CREATE)
141 {
142 struct itimerspec it;
143 struct sigevent ev;
144
145 ev.sigev_notify = SIGEV_SIGNAL;
146 ev.sigev_signo = ITIMER_SIGNAL;
147
148 it.it_value.tv_sec = ms / 1000;
149 it.it_value.tv_nsec = (ms % 1000) * 1000000;
150 it.it_interval = it.it_value;
151
152 if (timer_create(TIMER_FLAVOUR, &ev, &timer) != 0) {
153 sysErrorBelch("timer_create");
154 stg_exit(EXIT_FAILURE);
155 }
156
157 if (timer_settime(timer, 0, &it, NULL) != 0) {
158 sysErrorBelch("timer_settime");
159 stg_exit(EXIT_FAILURE);
160 }
161 }
162 #else
163 {
164 struct itimerval it;
165
166 it.it_value.tv_sec = ms / 1000;
167 it.it_value.tv_usec = (ms % 1000) * 1000;
168 it.it_interval = it.it_value;
169
170 if (setitimer(ITIMER_FLAVOUR, &it, NULL) != 0) {
171 sysErrorBelch("setitimer");
172 stg_exit(EXIT_FAILURE);
173 }
174 }
175 #endif
176 }
177
178 void
179 stopTicker(void)
180 {
181 #if defined(USE_TIMER_CREATE)
182 struct itimerspec it;
183
184 it.it_value.tv_sec = 0;
185 it.it_value.tv_nsec = 0;
186 it.it_interval = it.it_value;
187
188 if (timer_settime(timer, 0, &it, NULL) != 0) {
189 sysErrorBelch("timer_settime");
190 stg_exit(EXIT_FAILURE);
191 }
192 #else
193 struct itimerval it;
194
195 it.it_value.tv_sec = 0;
196 it.it_value.tv_usec = 0;
197 it.it_interval = it.it_value;
198
199 if (setitimer(ITIMER_FLAVOUR, &it, NULL) != 0) {
200 sysErrorBelch("setitimer");
201 stg_exit(EXIT_FAILURE);
202 }
203 #endif
204 }
205
206 #if 0
207 /* Currently unused */
208 void
209 block_vtalrm_signal(void)
210 {
211 sigset_t signals;
212
213 sigemptyset(&signals);
214 sigaddset(&signals, ITIMER_SIGNAL);
215
216 (void) sigprocmask(SIG_BLOCK, &signals, NULL);
217 }
218
219 void
220 unblock_vtalrm_signal(void)
221 {
222 sigset_t signals;
223
224 sigemptyset(&signals);
225 sigaddset(&signals, ITIMER_SIGNAL);
226
227 (void) sigprocmask(SIG_UNBLOCK, &signals, NULL);
228 }
229 #endif
230
231 /* gettimeofday() takes around 1us on our 500MHz PIII. Since we're
232 * only calling it 50 times/s, it shouldn't have any great impact.
233 */
234 lnat
235 getourtimeofday(void)
236 {
237 struct timeval tv;
238 gettimeofday(&tv, (struct timezone *) NULL);
239 // cast to lnat because nat may be 64 bit when int is only 32 bit
240 return ((lnat)tv.tv_sec * 1000 / RtsFlags.MiscFlags.tickInterval +
241 (lnat)tv.tv_usec / (RtsFlags.MiscFlags.tickInterval * 1000));
242 }