/* -----------------------------------------------------------------------------
- * $Id: Itimer.c,v 1.10 2000/03/14 01:43:27 sof Exp $
*
* (c) The GHC Team, 1995-1999
*
* Hence, we use the old-fashioned @setitimer@ that just about everyone seems
* to support. So much for standards.
*/
-
-#if !defined(_AIX)
-# define NON_POSIX_SOURCE
-#endif
-
#include "Rts.h"
+#include "RtsFlags.h"
+#include "Timer.h"
#include "Itimer.h"
+#include "Proftimer.h"
#include "Schedule.h"
/* As recommended in the autoconf manual */
# endif
# endif
-#if HAVE_WINDOWS_H
-# include <windows.h>
+#ifdef HAVE_SIGNAL_H
+# include <signal.h>
#endif
-
-lnat total_ticks = 0;
-rtsBool do_prof_ticks = rtsFalse;
-static
-void
-#if defined(mingw32_TARGET_OS) || (defined(cygwin32_TARGET_OS) && !defined(HAVE_SETITIMER))
-CALLBACK
+/* Major bogosity:
+ *
+ * In the threaded RTS, we can't set the virtual timer because the
+ * thread which has the virtual timer might be sitting waiting for a
+ * capability, and the virtual timer only ticks in CPU time.
+ *
+ * So, possible solutions:
+ *
+ * (1) tick in realtime. Not very good, because this ticker is used for
+ * profiling, and this will give us unreliable time profiling
+ * results. Furthermore, this requires picking a single OS thread
+ * to be the timekeeper, which is a bad idea because the thread in
+ * question might just be making a temporary call into Haskell land.
+ *
+ * (2) save/restore the virtual timer around excursions into STG land.
+ * Sounds great, but I tried it and the resolution of the virtual timer
+ * isn't good enough (on Linux) - most of our excursions fall
+ * within the timer's resolution and we never make any progress.
+ *
+ * (3) have a virtual timer in every OS thread. Might be reasonable,
+ * because most of the time there is only ever one of these
+ * threads running, so it approximates a single virtual timer.
+ * But still quite bogus (and I got crashes when I tried this).
+ *
+ * For now, we're using (1), but this needs a better solution. --SDM
+ */
+#ifdef RTS_SUPPORTS_THREADS
+#define ITIMER_FLAVOUR ITIMER_REAL
+#define ITIMER_SIGNAL SIGALRM
+#else
+#define ITIMER_FLAVOUR ITIMER_VIRTUAL
+#define ITIMER_SIGNAL SIGVTALRM
#endif
-handle_tick(int unused STG_UNUSED);
-
-/* -----------------------------------------------------------------------------
- Tick handler
-
- We use the ticker for two things: supporting threadDelay, and time
- profiling.
-
- SMP note: this signal could be delivered to *any* thread. We have
- to ensure that it doesn't matter which thread actually runs the
- signal handler.
- -------------------------------------------------------------------------- */
static
-void
-#if defined(mingw32_TARGET_OS) || (defined(cygwin32_TARGET_OS) && !defined(HAVE_SETITIMER))
-CALLBACK
-#endif
-handle_tick(int unused STG_UNUSED)
+int
+install_vtalrm_handler(TickProc handle_tick)
{
- total_ticks++;
+ struct sigaction action;
-#ifdef PROFILING
- if (do_prof_ticks == rtsTrue) {
- CCS_TICK(CCCS);
- }
-#endif
+ action.sa_handler = handle_tick;
+
+ sigemptyset(&action.sa_mask);
+ action.sa_flags = 0;
- /* For threadDelay etc., see Select.c */
- ticks_since_select++;
+ return sigaction(ITIMER_SIGNAL, &action, NULL);
}
+int
+startTicker(nat ms, TickProc handle_tick)
+{
+# ifndef HAVE_SETITIMER
+ /* debugBelch("No virtual timer on this system\n"); */
+ return -1;
+# else
+ struct itimerval it;
-/*
- * Handling timer events under cygwin32 is not done with signal/setitimer.
- * Instead of the two steps of first registering a signal handler to handle
- * \tr{SIGVTALRM} and then start generating them via @setitimer()@, we use
- * the Multimedia API (MM) and its @timeSetEvent@. (Internally, the MM API
- * creates a separate thread that will notify the main thread of timer
- * expiry). -- SOF 7/96
- *
- * 11/98: if the cygwin DLL supports setitimer(), then use it instead.
- */
+ install_vtalrm_handler(handle_tick);
-#if defined(mingw32_TARGET_OS) || (defined(cygwin32_TARGET_OS) && !defined(HAVE_SETITIMER))
+ timestamp = getourtimeofday();
-/*
- * Sigh - to avoid requiring anyone that wants to build ghc to have
- * to augment the Win32 header files that comes with cygwinb20.1,
- * include the missing MM API decls here inline.
- *
- * ToDo: check and remove these once the next version of cygwin is
- * released.
- */
-#define TIMERR_NOERROR 0
-#define TIMERR_NOCANDO 97
-#define TIME_PERIODIC 1
-
-typedef UINT MMRESULT;
-typedef void CALLBACK (*TIMECALLBACK) (UINT, UINT, DWORD, DWORD, DWORD);
-typedef TIMECALLBACK *LPTIMECALLBACK;
-MMRESULT STDCALL timeSetEvent(UINT, UINT, LPTIMECALLBACK, DWORD, UINT);
-/*
- vtalrm_handler is assigned and set up in Signals.c
-
- vtalrm_id (defined in Signals.c) holds
- the system id for the current timer (used to
- later block/kill it.)
-*/
-extern nat vtalrm_id;
-TIMECALLBACK *vtalrm_cback;
-
-nat
-initialize_virtual_timer(nat ms)
-{
-# ifdef PROFILING
- /* On Win32 setups that don't have support for
- setitimer(), we use the MultiMedia API's timer
- support.
-
- As the delivery of ticks isn't free, we only
- enable it if we really needed, i.e., when profiling.
- (the RTS now also needs timer ticks to implement
- threadDelay in non-profiling mode, but the pure
- Win32 port doesn't support that.....yet.)
- */
- unsigned int delay,vtalrm_id;
-
- delay = timeBeginPeriod(1);
- if (delay == TIMERR_NOCANDO) { /* error of some sort. */
- return delay;
- }
- vtalrm_id =
- timeSetEvent(ms, /* event every `delay' milliseconds. */
- 1, /* precision is within 5 millisecs. */
- (LPTIMECALLBACK)vtalrm_cback,
- 0,
- TIME_PERIODIC);
+ it.it_value.tv_sec = ms / 1000;
+ it.it_value.tv_usec = 1000 * (ms - (1000 * it.it_value.tv_sec));
+ it.it_interval = it.it_value;
+ return (setitimer(ITIMER_FLAVOUR, &it, NULL));
# endif
- return 0;
}
-
-#else
-nat
-initialize_virtual_timer(nat ms)
+int
+stopTicker()
{
# ifndef HAVE_SETITIMER
- fprintf(stderr, "No virtual timer on this system\n");
+ /* debugBelch("No virtual timer on this system\n"); */
return -1;
# else
struct itimerval it;
-
- it.it_value.tv_sec = ms / 1000;
- it.it_value.tv_usec = 1000 * (ms - (1000 * it.it_value.tv_sec));
+
+ it.it_value.tv_sec = 0;
+ it.it_value.tv_usec = 0;
it.it_interval = it.it_value;
- return (setitimer(ITIMER_VIRTUAL, &it, NULL));
+ return (setitimer(ITIMER_FLAVOUR, &it, NULL));
# endif
}
-#endif /* !cygwin32_TARGET_OS */
-
# if 0
/* This is a potential POSIX version */
-nat
-initialize_virtual_timer(nat ms)
+int
+startTicker(nat ms)
{
struct sigevent se;
struct itimerspec it;
timer_t tid;
+ timestamp = getourtimeofday();
+
se.sigev_notify = SIGEV_SIGNAL;
- se.sigev_signo = SIGVTALRM;
- se.sigev_value.sival_int = SIGVTALRM;
+ se.sigev_signo = ITIMER_SIGNAL;
+ se.sigev_value.sival_int = ITIMER_SIGNAL;
if (timer_create(CLOCK_VIRTUAL, &se, &tid)) {
barf("can't create virtual timer");
}
it.it_value.tv_sec = ms / 1000;
it.it_value.tv_nsec = 1000000 * (ms - 1000 * it.it_value.tv_sec);
it.it_interval = it.it_value;
- timer_settime(tid, TIMER_RELTIME, &it, NULL);
-}
-# endif
-
-#if defined(mingw32_TARGET_OS) || (defined(cygwin32_TARGET_OS) && !defined(HAVE_SETITIMER))
-int
-install_vtalrm_handler(void)
-{
- vtalrm_cback = handle_tick;
- return 0;
+ return timer_settime(tid, TIMER_RELTIME, &it, NULL);
}
-#else
int
-install_vtalrm_handler(void)
+stopTicker()
{
- struct sigaction action;
-
- action.sa_handler = handle_tick;
+ struct sigevent se;
+ struct itimerspec it;
+ timer_t tid;
- sigemptyset(&action.sa_mask);
- action.sa_flags = 0;
+ timestamp = getourtimeofday();
- return sigaction(SIGVTALRM, &action, NULL);
+ se.sigev_notify = SIGEV_SIGNAL;
+ se.sigev_signo = ITIMER_SIGNAL;
+ se.sigev_value.sival_int = ITIMER_SIGNAL;
+ if (timer_create(CLOCK_VIRTUAL, &se, &tid)) {
+ barf("can't create virtual timer");
+ }
+ it.it_value.tv_sec = 0;
+ it.it_value.tv_nsec = 0;
+ it.it_interval = it.it_value;
+ return timer_settime(tid, TIMER_RELTIME, &it, NULL);
}
+# endif
+#if 0
+/* Currently unused */
void
block_vtalrm_signal(void)
{
sigset_t signals;
sigemptyset(&signals);
- sigaddset(&signals, SIGVTALRM);
+ sigaddset(&signals, ITIMER_SIGNAL);
(void) sigprocmask(SIG_BLOCK, &signals, NULL);
}
sigset_t signals;
sigemptyset(&signals);
- sigaddset(&signals, SIGVTALRM);
+ sigaddset(&signals, ITIMER_SIGNAL);
(void) sigprocmask(SIG_UNBLOCK, &signals, NULL);
}
#endif
+
+/* gettimeofday() takes around 1us on our 500MHz PIII. Since we're
+ * only calling it 50 times/s, it shouldn't have any great impact.
+ */
+nat
+getourtimeofday(void)
+{
+ struct timeval tv;
+ gettimeofday(&tv, (struct timezone *) NULL);
+ // cast to nat because nat may be 64 bit when int is only 32 bit
+ return ((nat)tv.tv_sec * TICK_FREQUENCY +
+ (nat)tv.tv_usec * TICK_FREQUENCY / 1000000);
+}
+