X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Frts%2FRtsStartup.c;h=5255386de36b186a6d3cf3b46d8ad5bc09ae82dc;hb=8fcae518e33613c93b55ab5f165954727cf4aa30;hp=ce133dce10d32d8124f157c2a5684e5f85cad8e3;hpb=b240523ec7c29cf6bef4d51f234d386a84949852;p=ghc-hetmet.git diff --git a/ghc/rts/RtsStartup.c b/ghc/rts/RtsStartup.c index ce133dc..5255386 100644 --- a/ghc/rts/RtsStartup.c +++ b/ghc/rts/RtsStartup.c @@ -1,7 +1,7 @@ /* ----------------------------------------------------------------------------- - * $Id: RtsStartup.c,v 1.59 2001/12/06 07:07:12 sof Exp $ + * $Id: RtsStartup.c,v 1.79 2004/02/27 13:35:16 simonmar Exp $ * - * (c) The GHC Team, 1998-2000 + * (c) The GHC Team, 1998-2002 * * Main function for a standalone Haskell program. * @@ -17,7 +17,7 @@ #include "Schedule.h" /* initScheduler */ #include "Stats.h" /* initStats */ #include "Signals.h" -#include "Itimer.h" +#include "Timer.h" /* startTimer, stopTimer */ #include "Weak.h" #include "Ticky.h" #include "StgRun.h" @@ -25,6 +25,7 @@ #include "Prelude.h" /* fixupRTStoPreludeRefs */ #include "HsFFI.h" #include "Linker.h" +#include "ThreadLabels.h" #if defined(RTS_GTK_FRONTPANEL) #include "FrontPanel.h" @@ -49,52 +50,61 @@ # include "LLC.h" #endif -/* - * Flag Structure - */ -struct RTS_FLAGS RtsFlags; +#if defined(mingw32_TARGET_OS) +#include "win32/AsyncIO.h" +#endif -static int rts_has_started_up = 0; -#if defined(PAR) -ullong startTime = 0; +#include + +#ifdef HAVE_LOCALE_H +#include #endif -EXTFUN(__stginit_Prelude); -static void initModules ( void (*)(void) ); +#ifdef HAVE_TERMIOS_H +#include +#endif +#ifdef HAVE_SIGNAL_H +#include +#endif -void -setProgArgv(int argc, char *argv[]) +// Flag Structure +struct RTS_FLAGS RtsFlags; + +// Count of how many outstanding hs_init()s there have been. +static int hs_init_count = 0; + +// Here we save the terminal settings on the standard file +// descriptors, if we need to change them (eg. to support NoBuffering +// input). +static void *saved_termios[3] = {NULL,NULL,NULL}; + +void* +__hscore_get_saved_termios(int fd) { - /* Usually this is done by startupHaskell, so we don't need to call this. - However, sometimes Hugs wants to change the arguments which Haskell - getArgs >>= ... will be fed. So you can do that by calling here - _after_ calling startupHaskell. - */ - prog_argc = argc; - prog_argv = argv; + return (0 <= fd && fd < (int)(sizeof(saved_termios) / sizeof(*saved_termios))) ? + saved_termios[fd] : NULL; } void -getProgArgv(int *argc, char **argv[]) +__hscore_set_saved_termios(int fd, void* ts) { - *argc = prog_argc; - *argv = prog_argv; + if (0 <= fd && fd < (int)(sizeof(saved_termios) / sizeof(*saved_termios))) { + saved_termios[fd] = ts; + } } +/* ----------------------------------------------------------------------------- + Starting up the RTS + -------------------------------------------------------------------------- */ void -startupHaskell(int argc, char *argv[], void (*init_root)(void)) +hs_init(int *argc, char **argv[]) { - /* To avoid repeated initialisations of the RTS */ - if (rts_has_started_up) { - /* RTS is up and running, so only run the per-module initialisation code */ - if (init_root) { - initModules(init_root); + hs_init_count++; + if (hs_init_count > 1) { + // second and subsequent inits are ignored + return; } - return; - } else { - rts_has_started_up=1; - } /* The very first thing we do is grab the start time...just in case we're * collecting timing statistics. @@ -124,9 +134,11 @@ startupHaskell(int argc, char *argv[], void (*init_root)(void)) defaultsHook(); /* Parse the flags, separating the RTS flags from the programs args */ - setupRtsFlags(&argc, argv, &rts_argc, rts_argv); - prog_argc = argc; - prog_argv = argv; + if (argc != NULL && argv != NULL) { + setupRtsFlags(argc, *argv, &rts_argc, rts_argv); + prog_argc = *argc; + prog_argv = *argv; + } #if defined(PAR) /* NB: this really must be done after processing the RTS flags */ @@ -156,45 +168,78 @@ startupHaskell(int argc, char *argv[], void (*init_root)(void)) /* initialise the stable pointer table */ initStablePtrTable(); -#if defined(PROFILING) || defined(DEBUG) - initProfiling1(); -#endif - - /* run the per-module initialisation code */ - initModules(init_root); + /* initialise thread label table (tso->char*) */ + initThreadLabelTable(); #if defined(PROFILING) || defined(DEBUG) - initProfiling2(); + initProfiling1(); #endif /* start the virtual timer 'subsystem'. */ - startVirtTimer(TICK_MILLISECS); - - /* start our haskell execution tasks */ -#ifdef SMP - startTasks(); -#endif + startTimer(TICK_MILLISECS); /* Initialise the stats department */ initStats(); -#if !defined(mingw32_TARGET_OS) && !defined(PAR) +#if defined(RTS_USER_SIGNALS) /* Initialise the user signal handler set */ initUserSignals(); /* Set up handler to run on SIGINT, etc. */ initDefaultHandlers(); #endif +#if defined(mingw32_TARGET_OS) + startupAsyncIO(); +#endif + #ifdef RTS_GTK_FRONTPANEL if (RtsFlags.GcFlags.frontpanel) { initFrontPanel(); } #endif +#ifdef HAVE_LOCALE_H + setlocale(LC_ALL,""); +#endif + /* Record initialization times */ stat_endInit(); } +// Compatibility interface +void +startupHaskell(int argc, char *argv[], void (*init_root)(void)) +{ + hs_init(&argc, &argv); + hs_add_root(init_root); +} + + +/* ----------------------------------------------------------------------------- + Getting/Setting the program's arguments. + + These are used by System.Environment. + -------------------------------------------------------------------------- */ + +void +getProgArgv(int *argc, char **argv[]) +{ + if (argc) { *argc = prog_argc; } + if (argv) { *argv = prog_argv; } +} + +void +setProgArgv(int argc, char *argv[]) +{ + /* Usually this is done by startupHaskell, so we don't need to call this. + However, sometimes Hugs wants to change the arguments which Haskell + getArgs >>= ... will be fed. So you can do that by calling here + _after_ calling startupHaskell. + */ + prog_argc = argc; + prog_argv = argv; +} + /* ----------------------------------------------------------------------------- Per-module initialisation @@ -213,8 +258,7 @@ startupHaskell(int argc, char *argv[], void (*init_root)(void)) The code generator inserts a small function "__stginit_" in each module and calls the registration functions in each of the modules it - imports. So, if we call "__stginit_PrelMain", each reachable module in the - program will be registered (because PrelMain.mainIO calls Main.main). + imports. The init* functions are compiled in the same way as STG code, i.e. without normal C call/return conventions. Hence we must use @@ -224,11 +268,10 @@ startupHaskell(int argc, char *argv[], void (*init_root)(void)) /* The init functions use an explicit stack... */ #define INIT_STACK_BLOCKS 4 -F_ *init_stack = NULL; -nat init_sp = 0; +static F_ *init_stack = NULL; -static void -initModules ( void (*init_root)(void) ) +void +hs_add_root(void (*init_root)(void)) { bdescr *bd; #ifdef SMP @@ -236,12 +279,16 @@ initModules ( void (*init_root)(void) ) #else #define cap MainCapability #endif + nat init_sp; + + if (hs_init_count <= 0) { + barf("hs_add_root() must be called after hs_init()"); + } init_sp = 0; bd = allocGroup(INIT_STACK_BLOCKS); init_stack = (F_ *)bd->start; init_stack[init_sp++] = (F_)stg_init_ret; - init_stack[init_sp++] = (F_)__stginit_Prelude; if (init_root != NULL) { init_stack[init_sp++] = (F_)init_root; } @@ -250,75 +297,92 @@ initModules ( void (*init_root)(void) ) StgRun((StgFunPtr)stg_init, &cap.r); freeGroup(bd); -} -/* ----------------------------------------------------------------------------- - * Shutting down the RTS - two ways of doing this, one which - * calls exit(), one that doesn't. - * - * (shutdownHaskellAndExit() is called by System.exitWith). - * ----------------------------------------------------------------------------- - */ -void -shutdownHaskellAndExit(int n) -{ - OnExitHook(); - shutdownHaskell(); -#if defined(PAR) - /* really exit (stg_exit() would call shutdownParallelSystem() again) */ - exit(n); -#else - stg_exit(n); +#if defined(PROFILING) || defined(DEBUG) + // This must be done after module initialisation. + // ToDo: make this work in the presence of multiple hs_add_root()s. + initProfiling2(); #endif } +/* ----------------------------------------------------------------------------- + Shutting down the RTS + -------------------------------------------------------------------------- */ + void -shutdownHaskell(void) +hs_exit(void) { - if (!rts_has_started_up) - return; - - /* start timing the shutdown */ - stat_startExit(); + if (hs_init_count <= 0) { + barf("too many hs_exit()s"); + } + hs_init_count--; + if (hs_init_count > 0) { + // ignore until it's the last one + return; + } + /* start timing the shutdown */ + stat_startExit(); + #if !defined(GRAN) - /* Finalize any remaining weak pointers */ - finalizeWeakPointersNow(); + /* Finalize any remaining weak pointers */ + finalizeWeakPointersNow(); #endif - + + /* stop all running tasks */ + exitScheduler(); + #if defined(GRAN) - /* end_gr_simulation prints global stats if requested -- HWL */ - if (!RtsFlags.GranFlags.GranSimStats.Suppressed) - end_gr_simulation(); + /* end_gr_simulation prints global stats if requested -- HWL */ + if (!RtsFlags.GranFlags.GranSimStats.Suppressed) + end_gr_simulation(); +#endif + + /* stop the ticker */ + stopTimer(); + + /* reset the standard file descriptors to blocking mode */ + resetNonBlockingFd(0); + resetNonBlockingFd(1); + resetNonBlockingFd(2); + +#if HAVE_TERMIOS_H + // Reset the terminal settings on the standard file descriptors, + // if we changed them. See System.Posix.Internals.tcSetAttr for + // more details, including the reason we termporarily disable + // SIGTTOU here. + { + int fd; + sigset_t sigset, old_sigset; + sigemptyset(&sigset); + sigaddset(&sigset, SIGTTOU); + sigprocmask(SIG_BLOCK, &sigset, &old_sigset); + for (fd = 0; fd <= 2; fd++) { + struct termios* ts = (struct termios*)__hscore_get_saved_termios(fd); + if (ts != NULL) { + tcsetattr(fd,TCSANOW,ts); + } + } + sigprocmask(SIG_SETMASK, &old_sigset, NULL); + } #endif - - /* stop all running tasks */ - exitScheduler(); - - /* stop the ticker */ - stopVirtTimer(); - - /* reset the standard file descriptors to blocking mode */ - resetNonBlockingFd(0); - resetNonBlockingFd(1); - resetNonBlockingFd(2); #if defined(PAR) - /* controlled exit; good thread! */ - shutdownParallelSystem(0); - - /* global statistics in parallel system */ - PAR_TICKY_PAR_END(); + /* controlled exit; good thread! */ + shutdownParallelSystem(0); + + /* global statistics in parallel system */ + PAR_TICKY_PAR_END(); #endif - /* stop timing the shutdown, we're about to print stats */ - stat_endExit(); - - /* clean up things from the storage manager's point of view. - * also outputs the stats (+RTS -s) info. - */ - exitStorage(); - + /* stop timing the shutdown, we're about to print stats */ + stat_endExit(); + + /* clean up things from the storage manager's point of view. + * also outputs the stats (+RTS -s) info. + */ + exitStorage(); + #ifdef RTS_GTK_FRONTPANEL if (RtsFlags.GcFlags.frontpanel) { stopFrontPanel(); @@ -326,25 +390,49 @@ shutdownHaskell(void) #endif #if defined(PROFILING) - report_ccs_profiling(); + reportCCSProfiling(); #endif #if defined(PROFILING) || defined(DEBUG) - endProfiling(); + endProfiling(); #endif #ifdef PROFILING - // Originally, this was in report_ccs_profiling(). Now, retainer - // profiling might tack some extra stuff on to the end of this file - // during endProfiling(). - fclose(prof_file); + // Originally, this was in report_ccs_profiling(). Now, retainer + // profiling might tack some extra stuff on to the end of this file + // during endProfiling(). + fclose(prof_file); #endif - + #if defined(TICKY_TICKY) - if (RtsFlags.TickyFlags.showTickyStats) PrintTickyInfo(); + if (RtsFlags.TickyFlags.showTickyStats) PrintTickyInfo(); #endif - rts_has_started_up=0; +#if defined(mingw32_TARGET_OS) + shutdownAsyncIO(); +#endif +} + +// Compatibility interfaces +void +shutdownHaskell(void) +{ + hs_exit(); +} + +void +shutdownHaskellAndExit(int n) +{ + if (hs_init_count == 1) { + OnExitHook(); + hs_exit(); +#if defined(PAR) + /* really exit (stg_exit() would call shutdownParallelSystem() again) */ + exit(n); +#else + stg_exit(n); +#endif + } } /* @@ -356,7 +444,7 @@ static int exit_started=rtsFalse; #endif void -stg_exit(I_ n) +stg_exit(int n) { #ifdef PAR /* HACK: avoid a loop when exiting due to a stupid error */