X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2FRtsStartup.c;h=fbebdb9c41d2513a12a3163a0a627cc74b0885d0;hb=66579ff945831c5fc9a17c58c722ff01f2268d76;hp=7dce06e640147c7d95667414988b45ecbb1fceb2;hpb=16a5bb82bce0388962a5d64682072439b5fa8795;p=ghc-hetmet.git diff --git a/rts/RtsStartup.c b/rts/RtsStartup.c index 7dce06e..fbebdb9 100644 --- a/rts/RtsStartup.c +++ b/rts/RtsStartup.c @@ -33,6 +33,7 @@ #include "RtsTypeable.h" #include "Stable.h" #include "Hpc.h" +#include "FileLock.h" #if defined(RTS_GTK_FRONTPANEL) #include "FrontPanel.h" @@ -70,6 +71,9 @@ #ifdef HAVE_SIGNAL_H #include #endif +#ifdef HAVE_UNISTD_H +#include +#endif #if USE_PAPI #include "Papi.h" @@ -139,17 +143,20 @@ hs_init(int *argc, char **argv[]) return; } -#if defined(DEBUG) - /* Start off by initialising the allocator debugging so we can - * use it anywhere */ - initAllocator(); -#endif + /* Initialise the stats department, phase 0 */ + initStats0(); /* Next we do is grab the start time...just in case we're * collecting timing statistics. */ stat_startInit(); +#if defined(DEBUG) + /* Start off by initialising the allocator debugging so we can + * use it anywhere */ + initAllocator(); +#endif + #ifdef PAR /* * The parallel system needs to be initialised and synchronised before @@ -166,30 +173,6 @@ hs_init(int *argc, char **argv[]) argv++; argc--; #endif - /* Initialise the performance tracking library */ -#ifdef USE_PAPI - { - int ver; - if ((ver = PAPI_library_init(PAPI_VER_CURRENT)) != PAPI_VER_CURRENT) { - if (ver > 0) { - errorBelch("PAPI_library_init: wrong version: %x", ver); - stg_exit(EXIT_FAILURE); - } else { - sysErrorBelch("PAPI_library_init"); - stg_exit(EXIT_FAILURE); - } - } - } -#ifdef THREADED_RTS - { - int err; - if ((err = PAPI_thread_init(osThreadId)) < 0) { - barf("PAPI_thread_init: %d",err); - } - } -#endif -#endif - /* Set the RTS flags to default values. */ initRtsFlagsDefaults(); @@ -199,10 +182,18 @@ hs_init(int *argc, char **argv[]) /* Parse the flags, separating the RTS flags from the programs args */ if (argc != NULL && argv != NULL) { + setFullProgArgv(*argc,*argv); setupRtsFlags(argc, *argv, &rts_argc, rts_argv); setProgArgv(*argc,*argv); } + /* Initialise the stats department, phase 1 */ + initStats1(); + +#ifdef USE_PAPI + papi_init(); +#endif + /* initTracing must be after setupRtsFlags() */ initTracing(); @@ -234,9 +225,28 @@ hs_init(int *argc, char **argv[]) /* initialise the stable pointer table */ initStablePtrTable(); + /* Add some GC roots for things in the base package that the RTS + * knows about. We don't know whether these turn out to be CAFs + * or refer to CAFs, but we have to assume that they might. + */ + getStablePtr((StgPtr)base_GHCziTopHandler_runIO_closure); + getStablePtr((StgPtr)base_GHCziTopHandler_runNonIO_closure); + getStablePtr((StgPtr)stackOverflow_closure); + getStablePtr((StgPtr)heapOverflow_closure); + getStablePtr((StgPtr)runFinalizerBatch_closure); + getStablePtr((StgPtr)unpackCString_closure); + getStablePtr((StgPtr)blockedOnDeadMVar_closure); + getStablePtr((StgPtr)nonTermination_closure); + getStablePtr((StgPtr)blockedIndefinitely_closure); + /* initialise the shared Typeable store */ initTypeableStore(); + /* initialise file locking, if necessary */ +#if !defined(mingw32_HOST_OS) + initFileLocking(); +#endif + #if defined(DEBUG) /* initialise thread label table (tso->char*) */ initThreadLabelTable(); @@ -245,11 +255,9 @@ hs_init(int *argc, char **argv[]) initProfiling1(); /* start the virtual timer 'subsystem'. */ + initTimer(); startTimer(); - /* Initialise the stats department */ - initStats(); - #if defined(RTS_USER_SIGNALS) if (RtsFlags.MiscFlags.install_signal_handlers) { /* Initialise the user signal handler set */ @@ -273,10 +281,6 @@ hs_init(int *argc, char **argv[]) x86_init_fpu(); #endif -#if defined(THREADED_RTS) - ioManagerStart(); -#endif - /* Record initialization times */ stat_endInit(); } @@ -326,7 +330,9 @@ hs_add_root(void (*init_root)(void)) { bdescr *bd; nat init_sp; - Capability *cap = &MainCapability; + Capability *cap; + + cap = rts_lock(); if (hs_init_count <= 0) { barf("hs_add_root() must be called after hs_init()"); @@ -352,14 +358,34 @@ hs_add_root(void (*init_root)(void)) // This must be done after module initialisation. // ToDo: make this work in the presence of multiple hs_add_root()s. initProfiling2(); + + rts_unlock(cap); + + // ditto. +#if defined(THREADED_RTS) + ioManagerStart(); +#endif } -/* ----------------------------------------------------------------------------- - Shutting down the RTS - -------------------------------------------------------------------------- */ +/* ---------------------------------------------------------------------------- + * Shutting down the RTS + * + * The wait_foreign parameter means: + * True ==> wait for any threads doing foreign calls now. + * False ==> threads doing foreign calls may return in the + * future, but will immediately block on a mutex. + * (capability->lock). + * + * If this RTS is a DLL that we're about to unload, then you want + * safe=True, otherwise the thread might return to code that has been + * unloaded. If this is a standalone program that is about to exit, + * then you can get away with safe=False, which is better because we + * won't hang on exit if there is a blocked foreign call outstanding. + * + ------------------------------------------------------------------------- */ -void -hs_exit(void) +static void +hs_exit_(rtsBool wait_foreign) { if (hs_init_count <= 0) { errorBelch("warning: too many hs_exit()s"); @@ -374,6 +400,8 @@ hs_exit(void) /* start timing the shutdown */ stat_startExit(); + OnExitHook(); + #if defined(RTS_USER_SIGNALS) if (RtsFlags.MiscFlags.install_signal_handlers) { freeSignalHandlers(); @@ -385,7 +413,7 @@ hs_exit(void) #endif /* stop all running tasks */ - exitScheduler(); + exitScheduler(wait_foreign); #if defined(GRAN) /* end_gr_simulation prints global stats if requested -- HWL */ @@ -395,6 +423,7 @@ hs_exit(void) /* stop the ticker */ stopTimer(); + exitTimer(); /* reset the standard file descriptors to blocking mode */ resetNonBlockingFd(0); @@ -430,6 +459,9 @@ hs_exit(void) PAR_TICKY_PAR_END(); #endif + // uninstall signal handlers + resetDefaultHandlers(); + /* stop timing the shutdown, we're about to print stats */ stat_endExit(); @@ -446,11 +478,14 @@ hs_exit(void) /* free shared Typeable store */ exitTypeableStore(); + /* free file locking tables, if necessary */ +#if !defined(mingw32_HOST_OS) + freeFileLocking(); +#endif + /* free the stable pointer table */ exitStablePtrTable(); - freeProfiling1(); - #if defined(DEBUG) /* free the thread label table */ freeThreadLabelTable(); @@ -467,12 +502,13 @@ hs_exit(void) #endif endProfiling(); + freeProfiling1(); #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); + if (prof_file != NULL) fclose(prof_file); #endif #if defined(TICKY_TICKY) @@ -480,7 +516,7 @@ hs_exit(void) #endif #if defined(mingw32_HOST_OS) && !defined(THREADED_RTS) - shutdownAsyncIO(); + shutdownAsyncIO(wait_foreign); #endif /* free hash table storage */ @@ -496,6 +532,14 @@ hs_exit(void) } +// The real hs_exit(): +void +hs_exit(void) +{ + hs_exit_(rtsTrue); + // be safe; this might be a DLL +} + // Compatibility interfaces void shutdownHaskell(void) @@ -506,9 +550,10 @@ shutdownHaskell(void) void shutdownHaskellAndExit(int n) { - if (hs_init_count == 1) { - OnExitHook(); - hs_exit(); + // we're about to exit(), no need to wait for foreign calls to return. + hs_exit_(rtsFalse); + + if (hs_init_count == 0) { #if defined(PAR) /* really exit (stg_exit() would call shutdownParallelSystem() again) */ exit(n); @@ -518,6 +563,15 @@ shutdownHaskellAndExit(int n) } } +#ifndef mingw32_HOST_OS +void +shutdownHaskellAndSignal(int sig) +{ + hs_exit_(rtsFalse); + kill(getpid(),sig); +} +#endif + /* * called from STG-land to exit the program */