X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Frts%2FRtsStartup.c;h=edbf88a9c63accf99826fb0c24a576568f8a8b5c;hb=272a418428beede04a9c4ae027474878c59d6ca1;hp=49ccb428da3cf5ff1a54f1f86137c169083635ee;hpb=9dbc74ba4aea2b544ca889305a177f3f3921358f;p=ghc-hetmet.git diff --git a/ghc/rts/RtsStartup.c b/ghc/rts/RtsStartup.c index 49ccb42..edbf88a 100644 --- a/ghc/rts/RtsStartup.c +++ b/ghc/rts/RtsStartup.c @@ -1,12 +1,13 @@ /* ----------------------------------------------------------------------------- - * $Id: RtsStartup.c,v 1.12 1999/05/10 08:23:56 sof Exp $ + * $Id: RtsStartup.c,v 1.78 2003/09/26 12:12:35 panne Exp $ * - * (c) The GHC Team, 1998-1999 + * (c) The GHC Team, 1998-2002 * * Main function for a standalone Haskell program. * * ---------------------------------------------------------------------------*/ +#include "PosixSource.h" #include "Rts.h" #include "RtsAPI.h" #include "RtsUtils.h" @@ -15,66 +16,115 @@ #include "StablePriv.h" /* initStablePtrTable */ #include "Schedule.h" /* initScheduler */ #include "Stats.h" /* initStats */ +#include "Signals.h" +#include "Timer.h" /* startTimer, stopTimer */ #include "Weak.h" #include "Ticky.h" +#include "StgRun.h" +#include "StgStartup.h" +#include "Prelude.h" /* fixupRTStoPreludeRefs */ +#include "HsFFI.h" +#include "Linker.h" +#include "ThreadLabels.h" -#if defined(PROFILING) -# include "ProfRts.h" -#elif defined(DEBUG) -# include "DebugProf.h" +#if defined(RTS_GTK_FRONTPANEL) +#include "FrontPanel.h" #endif -#ifdef PAR -#include "ParInit.h" -#include "Parallel.h" -#include "LLC.h" +#if defined(PROFILING) || defined(DEBUG) +# include "Profiling.h" +# include "ProfHeap.h" +# include "RetainerProfile.h" #endif -/* - * Flag Structure - */ +#if defined(GRAN) +# include "GranSimRts.h" +#endif + +#if defined(GRAN) || defined(PAR) +# include "ParallelRts.h" +#endif + +#if defined(PAR) +# include "Parallel.h" +# include "LLC.h" +#endif + +#if defined(mingw32_TARGET_OS) +#include "win32/AsyncIO.h" +#endif + +#include + +#ifdef HAVE_LOCALE_H +#include +#endif + +#ifdef HAVE_TERMIOS_H +#include +#endif +#ifdef HAVE_SIGNAL_H +#include +#endif + +// 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) +{ + return (0 <= fd && fd < (int)(sizeof(saved_termios) / sizeof(*saved_termios))) ? + saved_termios[fd] : NULL; +} + void -startupHaskell(int argc, char *argv[]) +__hscore_set_saved_termios(int fd, void* ts) { - static int rts_has_started_up = 0; - int i; + if (0 <= fd && fd < (int)(sizeof(saved_termios) / sizeof(*saved_termios))) { + saved_termios[fd] = ts; + } +} - /* To avoid repeated initialisations of the RTS */ - if (rts_has_started_up) - return; - else - rts_has_started_up=1; +/* ----------------------------------------------------------------------------- + Starting up the RTS + -------------------------------------------------------------------------- */ -#if defined(PAR) - int nPEs = 0; /* Number of PEs */ -#endif +void +hs_init(int *argc, char **argv[]) +{ + hs_init_count++; + if (hs_init_count > 1) { + // second and subsequent inits are ignored + return; + } /* The very first thing we do is grab the start time...just in case we're * collecting timing statistics. */ - start_time(); + stat_startInit(); #ifdef PAR -/* - *The parallel system needs to be initialised and synchronised before - *the program is run. - */ - if (*argv[0] == '-') { /* Look to see whether we're the Main Thread */ - IAmMainThread = rtsTrue; - argv++; argc--; /* Strip off flag argument */ -/* fprintf(stderr, "I am Main Thread\n"); */ + /* + * The parallel system needs to be initialised and synchronised before + * the program is run. + */ + startupParallelSystem(argv); + + if (*argv[0] == '-') { /* Strip off mainPE flag argument */ + argv++; + argc--; } - /* - * Grab the number of PEs out of the argument vector, and - * eliminate it from further argument processing. - */ - nPEs = atoi(argv[1]); - argv[1] = argv[0]; + + argv[1] = argv[0]; /* ignore the nPEs argument */ argv++; argc--; - initEachPEHook(); /* HWL: hook to be execed on each PE */ - SynchroniseSystem(); #endif /* Set the RTS flags to default values. */ @@ -84,113 +134,327 @@ startupHaskell(int argc, char *argv[]) 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; + } -#ifdef PAR - /* Initialise the parallel system -- before initHeap! */ - initParallelSystem(); - /* And start GranSim profiling if required: omitted for now - *if (Rtsflags.ParFlags.granSimStats) - *init_gr_profiling(rts_argc, rts_argv, prog_argc, prog_argv); - */ +#if defined(PAR) + /* NB: this really must be done after processing the RTS flags */ + IF_PAR_DEBUG(verbose, + fprintf(stderr, "==== Synchronising system (%d PEs)\n", nPEs)); + synchroniseSystem(); // calls initParallelSystem etc #endif /* PAR */ + /* initialise scheduler data structures (needs to be done before + * initStorage()). + */ + initScheduler(); + +#if defined(GRAN) + /* And start GranSim profiling if required: */ + if (RtsFlags.GranFlags.GranSimStats.Full) + init_gr_simulation(rts_argc, rts_argv, prog_argc, prog_argv); +#elif defined(PAR) + /* And start GUM profiling if required: */ + if (RtsFlags.ParFlags.ParStats.Full) + init_gr_simulation(rts_argc, rts_argv, prog_argc, prog_argv); +#endif /* PAR || GRAN */ + /* initialize the storage manager */ initStorage(); /* initialise the stable pointer table */ initStablePtrTable(); + /* initialise thread label table (tso->char*) */ + initThreadLabelTable(); + #if defined(PROFILING) || defined(DEBUG) - initProfiling(); + initProfiling1(); #endif - /* Initialise the scheduler */ - initScheduler(); + /* start the virtual timer 'subsystem'. */ + startTimer(TICK_MILLISECS); /* Initialise the stats department */ initStats(); -#if 0 +#if defined(RTS_USER_SIGNALS) + /* Initialise the user signal handler set */ initUserSignals(); + /* Set up handler to run on SIGINT, etc. */ + initDefaultHandlers(); #endif - /* When the RTS and Prelude live in separate DLLs, - we need to patch up the char- and int-like tables - that the RTS keep after both DLLs have been loaded, - filling in the tables with references to where the - static info tables have been loaded inside the running - process. - */ -#ifdef ENABLE_WIN32_DLL_SUPPORT - for(i=0;i<=255;i++) - (CHARLIKE_closure[i]).header.info = (const StgInfoTable*)&Czh_static_info; - - for(i=0;i<=32;i++) - (INTLIKE_closure[i]).header.info = (const StgInfoTable*)&Izh_static_info; - +#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 */ - end_init(); + stat_endInit(); } +// Compatibility interface void -shutdownHaskell(void) +startupHaskell(int argc, char *argv[], void (*init_root)(void)) { - /* Finalize any remaining weak pointers */ - finalizeWeakPointersNow(); + hs_init(&argc, &argv); + hs_add_root(init_root); +} -#if defined(GRAN) - #error FixMe. - if (!RTSflags.GranFlags.granSimStats_suppressed) - end_gr_simulation(); + +/* ----------------------------------------------------------------------------- + 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 + + This process traverses all the compiled modules in the program + starting with "Main", and performing per-module initialisation for + each one. + + So far, two things happen at initialisation time: + + - we register stable names for each foreign-exported function + in that module. This prevents foreign-exported entities, and + things they depend on, from being garbage collected. + + - we supply a unique integer to each statically declared cost + centre and cost centre stack in the program. + + The code generator inserts a small function "__stginit_" in each + module and calls the registration functions in each of the modules it + 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 + StgRun to call this stuff. + -------------------------------------------------------------------------- */ + +/* The init functions use an explicit stack... + */ +#define INIT_STACK_BLOCKS 4 +static F_ *init_stack = NULL; + +void +hs_add_root(void (*init_root)(void)) +{ + bdescr *bd; +#ifdef SMP + Capability cap; +#else +#define cap MainCapability #endif + nat init_sp; + + if (hs_init_count <= 0) { + barf("hs_add_root() must be called after hs_init()"); + } - /* clean up things from the storage manager's point of view */ - exitStorage(); + init_sp = 0; + bd = allocGroup(INIT_STACK_BLOCKS); + init_stack = (F_ *)bd->start; + init_stack[init_sp++] = (F_)stg_init_ret; + if (init_root != NULL) { + init_stack[init_sp++] = (F_)init_root; + } + + cap.r.rSp = (P_)(init_stack + init_sp); + StgRun((StgFunPtr)stg_init, &cap.r); + + freeGroup(bd); #if defined(PROFILING) || defined(DEBUG) - endProfiling(); + // This must be done after module initialisation. + // ToDo: make this work in the presence of multiple hs_add_root()s. + initProfiling2(); #endif +} -#if defined(PROFILING) - report_ccs_profiling( ); +/* ----------------------------------------------------------------------------- + Shutting down the RTS + -------------------------------------------------------------------------- */ + +void +hs_exit(void) +{ + 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(); + + /* stop all running tasks */ + exitScheduler(); + +#if !defined(GRAN) + /* Finalize any remaining weak pointers */ + finalizeWeakPointersNow(); +#endif + +#if defined(GRAN) + /* 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 -#if defined(TICKY_TICKY) - if (RtsFlags.TickyFlags.showTickyStats) PrintTickyInfo(); +#if defined(PAR) + /* controlled exit; good thread! */ + shutdownParallelSystem(0); + + /* global statistics in parallel system */ + PAR_TICKY_PAR_END(); #endif - /* - This fflush is important, because: if "main" just returns, - then we will end up in pre-supplied exit code that will close - streams and flush buffers. In particular we have seen: it - will close fd 0 (stdin), then flush fd 1 (stdout), then ... + /* stop timing the shutdown, we're about to print stats */ + stat_endExit(); - But if you're playing with sockets, that "close fd 0" might - suggest to the daemon that all is over, only to be presented - with more stuff on "fd 1" at the flush. + /* clean up things from the storage manager's point of view. + * also outputs the stats (+RTS -s) info. + */ + exitStorage(); - The fflush avoids this sad possibility. - */ - fflush(stdout); +#ifdef RTS_GTK_FRONTPANEL + if (RtsFlags.GcFlags.frontpanel) { + stopFrontPanel(); + } +#endif + +#if defined(PROFILING) + reportCCSProfiling(); +#endif + +#if defined(PROFILING) || defined(DEBUG) + 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); +#endif + +#if defined(TICKY_TICKY) + if (RtsFlags.TickyFlags.showTickyStats) PrintTickyInfo(); +#endif + +#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 + } +} /* - * called from STG-land to exit the program cleanly + * called from STG-land to exit the program */ +#ifdef PAR +static int exit_started=rtsFalse; +#endif + void -stg_exit(I_ n) -{ +stg_exit(int n) +{ #ifdef PAR - par_exit(n); -#else - OnExitHook(); - exit(n); + /* HACK: avoid a loop when exiting due to a stupid error */ + if (exit_started) + return; + exit_started=rtsTrue; + + IF_PAR_DEBUG(verbose, fprintf(stderr,"==-- stg_exit %d on [%x]...", n, mytid)); + shutdownParallelSystem(n); #endif + exit(n); } +