Add several new record features
[ghc-hetmet.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(USE_TIMER_CREATE)
71
72 #  define ITIMER_SIGNAL SIGVTALRM
73 #  ifdef THREADED_RTS
74 #    define TIMER_FLAVOUR CLOCK_REALTIME
75 #  else
76 #    define TIMER_FLAVOUR CLOCK_PROCESS_CPUTIME_ID
77 #  endif
78
79 #elif defined(HAVE_SETITIMER)
80
81 #  ifdef THREADED_RTS
82 //   Oh dear, we have to use SIGALRM if there's no timer_create and
83 //   we're using the THREADED_RTS.  This leads to problems, see bug #850.
84 #    define ITIMER_SIGNAL  SIGALRM
85 #    define ITIMER_FLAVOUR ITIMER_REAL
86 #  else
87 #    define ITIMER_SIGNAL  SIGVTALRM
88 #    define ITIMER_FLAVOUR ITIMER_VIRTUAL
89 #  endif
90
91 #else
92
93 #  error No way to set an interval timer.
94
95 #endif
96
97 #if defined(USE_TIMER_CREATE)
98 timer_t timer;
99 #endif
100
101 static
102 void
103 install_vtalrm_handler(TickProc handle_tick)
104 {
105     struct sigaction action;
106
107     action.sa_handler = handle_tick;
108
109     sigemptyset(&action.sa_mask);
110
111 #ifdef SA_RESTART
112     // specify SA_RESTART.  One consequence if we don't do this is
113     // that readline gets confused by the -threaded RTS.  It seems
114     // that if a SIGALRM handler is installed without SA_RESTART,
115     // readline installs its own SIGALRM signal handler (see
116     // readline's signals.c), and this somehow causes readline to go
117     // wrong when the input exceeds a single line (try it).
118     action.sa_flags = SA_RESTART;
119 #else
120     action.sa_flags = 0;
121 #endif
122
123     if (sigaction(ITIMER_SIGNAL, &action, NULL) == -1) {
124         sysErrorBelch("sigaction");
125         stg_exit(EXIT_FAILURE);
126     }
127 }
128
129 void
130 startTicker(nat ms, TickProc handle_tick)
131 {
132     install_vtalrm_handler(handle_tick);
133
134 #if !defined(THREADED_RTS)
135     timestamp = getourtimeofday();
136 #endif
137
138 #if defined(USE_TIMER_CREATE)
139     {
140         struct itimerspec it;
141         struct sigevent ev;
142
143         ev.sigev_notify = SIGEV_SIGNAL;
144         ev.sigev_signo  = ITIMER_SIGNAL;
145         
146         it.it_value.tv_sec = ms / 1000;
147         it.it_value.tv_nsec = (ms % 1000) * 1000000;
148         it.it_interval = it.it_value;
149         
150         if (timer_create(TIMER_FLAVOUR, &ev, &timer) != 0) {
151             sysErrorBelch("timer_create");
152             stg_exit(EXIT_FAILURE);
153         }
154
155         if (timer_settime(timer, 0, &it, NULL) != 0) {
156             sysErrorBelch("timer_settime");
157             stg_exit(EXIT_FAILURE);
158         }
159     }
160 #else
161     {
162         struct itimerval it;
163
164         it.it_value.tv_sec = ms / 1000;
165         it.it_value.tv_usec = (ms % 1000) * 1000;
166         it.it_interval = it.it_value;
167         
168         if (setitimer(ITIMER_FLAVOUR, &it, NULL) != 0) {
169             sysErrorBelch("setitimer");
170             stg_exit(EXIT_FAILURE);
171         }
172     }
173 #endif
174 }
175
176 void
177 stopTicker(void)
178 {
179 #if defined(USE_TIMER_CREATE)
180     struct itimerspec it;
181
182     it.it_value.tv_sec = 0;
183     it.it_value.tv_nsec = 0;
184     it.it_interval = it.it_value;
185
186     if (timer_settime(timer, 0, &it, NULL) != 0) {
187         sysErrorBelch("timer_settime");
188         stg_exit(EXIT_FAILURE);
189     }
190 #else
191     struct itimerval it;
192
193     it.it_value.tv_sec = 0;
194     it.it_value.tv_usec = 0;
195     it.it_interval = it.it_value;
196
197     if (setitimer(ITIMER_FLAVOUR, &it, NULL) != 0) {
198         sysErrorBelch("setitimer");
199         stg_exit(EXIT_FAILURE);
200     }
201 #endif
202 }
203
204 #if 0
205 /* Currently unused */
206 void
207 block_vtalrm_signal(void)
208 {
209     sigset_t signals;
210     
211     sigemptyset(&signals);
212     sigaddset(&signals, ITIMER_SIGNAL);
213
214     (void) sigprocmask(SIG_BLOCK, &signals, NULL);
215 }
216
217 void
218 unblock_vtalrm_signal(void)
219 {
220     sigset_t signals;
221     
222     sigemptyset(&signals);
223     sigaddset(&signals, ITIMER_SIGNAL);
224
225     (void) sigprocmask(SIG_UNBLOCK, &signals, NULL);
226 }
227 #endif
228
229 /* gettimeofday() takes around 1us on our 500MHz PIII.  Since we're
230  * only calling it 50 times/s, it shouldn't have any great impact.
231  */
232 lnat
233 getourtimeofday(void)
234 {
235   struct timeval tv;
236   gettimeofday(&tv, (struct timezone *) NULL);
237         // cast to lnat because nat may be 64 bit when int is only 32 bit
238   return ((lnat)tv.tv_sec * 1000 / RtsFlags.MiscFlags.tickInterval +
239           (lnat)tv.tv_usec / (RtsFlags.MiscFlags.tickInterval * 1000));
240 }