X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=rts%2FRtsStartup.c;h=6ed837ab6c291236472e7bf2c3eeeeaaf8d1738b;hp=62a347a44d1bf6e24e28f0a5091b3c1af1b3a98a;hb=890f22ef8eff8dbb5b31fa221dfce65a7b84c202;hpb=93db1991b5cacf8357493a2e17fbbfb485f3205b diff --git a/rts/RtsStartup.c b/rts/RtsStartup.c index 62a347a..6ed837a 100644 --- a/rts/RtsStartup.c +++ b/rts/RtsStartup.c @@ -6,89 +6,68 @@ * * ---------------------------------------------------------------------------*/ +// PAPI uses caddr_t, which is not POSIX +#ifndef USE_PAPI #include "PosixSource.h" +#endif + #include "Rts.h" #include "RtsAPI.h" +#include "HsFFI.h" + +#include "sm/Storage.h" #include "RtsUtils.h" -#include "RtsFlags.h" -#include "OSThreads.h" -#include "Storage.h" /* initStorage, exitStorage */ +#include "Prelude.h" #include "Schedule.h" /* initScheduler */ #include "Stats.h" /* initStats */ #include "STM.h" /* initSTM */ -#include "Signals.h" #include "RtsSignals.h" -#include "Timer.h" /* startTimer, stopTimer */ #include "Weak.h" #include "Ticky.h" #include "StgRun.h" #include "Prelude.h" /* fixupRTStoPreludeRefs */ -#include "HsFFI.h" -#include "Linker.h" #include "ThreadLabels.h" -#include "BlockAlloc.h" +#include "sm/BlockAlloc.h" #include "Trace.h" -#include "RtsTypeable.h" +#include "Stable.h" +#include "Hash.h" +#include "Profiling.h" +#include "Timer.h" +#include "Globals.h" +void exitLinker( void ); // there is no Linker.h file to include #if defined(RTS_GTK_FRONTPANEL) #include "FrontPanel.h" #endif -#if defined(PROFILING) || defined(DEBUG) -# include "Profiling.h" +#if defined(PROFILING) # include "ProfHeap.h" # include "RetainerProfile.h" #endif -#if defined(GRAN) -# include "GranSimRts.h" +#if defined(mingw32_HOST_OS) && !defined(THREADED_RTS) +#include "win32/AsyncIO.h" #endif -#if defined(GRAN) || defined(PAR) -# include "ParallelRts.h" +#if !defined(mingw32_HOST_OS) +#include "posix/TTY.h" +#include "posix/FileLock.h" #endif -#if defined(PAR) -# include "Parallel.h" -# include "LLC.h" +#ifdef HAVE_UNISTD_H +#include #endif - -#if defined(mingw32_HOST_OS) -#include "win32/AsyncIO.h" +#ifdef HAVE_LOCALE_H +#include #endif -#include - -#ifdef HAVE_TERMIOS_H -#include -#endif -#ifdef HAVE_SIGNAL_H -#include +#if USE_PAPI +#include "Papi.h" #endif // 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 -__hscore_set_saved_termios(int fd, void* ts) -{ - if (0 <= fd && fd < (int)(sizeof(saved_termios) / sizeof(*saved_termios))) { - saved_termios[fd] = ts; - } -} - /* ----------------------------------------------------------------------------- Initialise floating point unit on x86 (currently disabled. why?) (see comment in ghc/compiler/nativeGen/MachInstrs.lhs). @@ -130,28 +109,18 @@ hs_init(int *argc, char **argv[]) return; } - /* The very first thing we do is grab the start time...just in case we're + setlocale(LC_CTYPE,""); + + /* 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(); -#ifdef PAR - /* - * 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--; - } - - argv[1] = argv[0]; /* ignore the nPEs argument */ - argv++; argc--; -#endif - /* Set the RTS flags to default values. */ + initRtsFlagsDefaults(); /* Call the user hook to reset defaults, if present */ @@ -159,70 +128,89 @@ 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); } - /* initTracing must be after setupRtsFlags() */ - initTracing(); + /* Initialise the stats department, phase 1 */ + initStats1(); -#if defined(PAR) - /* NB: this really must be done after processing the RTS flags */ - IF_PAR_DEBUG(verbose, - debugBelch("==== Synchronising system (%d PEs)\n", nPEs)); - synchroniseSystem(); // calls initParallelSystem etc -#endif /* PAR */ +#ifdef USE_PAPI + papi_init(); +#endif - /* Perform initialisation of adjustor thunk layer. */ - initAdjustor(); + /* initTracing must be after setupRtsFlags() */ +#ifdef TRACING + initTracing(); +#endif + /* Dtrace events are always enabled + */ + dtraceEventStartup(); /* 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(); + /* 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)runIO_closure); + getStablePtr((StgPtr)runNonIO_closure); + + getStablePtr((StgPtr)runFinalizerBatch_closure); + + getStablePtr((StgPtr)stackOverflow_closure); + getStablePtr((StgPtr)heapOverflow_closure); + getStablePtr((StgPtr)unpackCString_closure); + getStablePtr((StgPtr)blockedIndefinitelyOnMVar_closure); + getStablePtr((StgPtr)nonTermination_closure); + getStablePtr((StgPtr)blockedIndefinitelyOnSTM_closure); + getStablePtr((StgPtr)nestedAtomically_closure); + + getStablePtr((StgPtr)runSparks_closure); + getStablePtr((StgPtr)ensureIOManagerIsRunning_closure); +#ifndef mingw32_HOST_OS + getStablePtr((StgPtr)runHandlers_closure); +#endif + /* initialise the shared Typeable store */ - initTypeableStore(); + initGlobalStore(); + + /* initialise file locking, if necessary */ +#if !defined(mingw32_HOST_OS) + initFileLocking(); +#endif #if defined(DEBUG) /* initialise thread label table (tso->char*) */ initThreadLabelTable(); #endif -#if defined(PROFILING) || defined(DEBUG) initProfiling1(); -#endif /* start the virtual timer 'subsystem'. */ + initTimer(); startTimer(); - /* Initialise the stats department */ - initStats(); - #if defined(RTS_USER_SIGNALS) - /* Initialise the user signal handler set */ - initUserSignals(); - /* Set up handler to run on SIGINT, etc. */ - initDefaultHandlers(); + if (RtsFlags.MiscFlags.install_signal_handlers) { + /* Initialise the user signal handler set */ + initUserSignals(); + /* Set up handler to run on SIGINT, etc. */ + initDefaultHandlers(); + } #endif -#if defined(mingw32_HOST_OS) +#if defined(mingw32_HOST_OS) && !defined(THREADED_RTS) startupAsyncIO(); #endif @@ -236,10 +224,6 @@ hs_init(int *argc, char **argv[]) x86_init_fpu(); #endif -#if defined(THREADED_RTS) && !defined(mingw32_HOST_OS) - ioManagerStart(); -#endif - /* Record initialization times */ stat_endInit(); } @@ -282,14 +266,16 @@ startupHaskell(int argc, char *argv[], void (*init_root)(void)) /* The init functions use an explicit stack... */ #define INIT_STACK_BLOCKS 4 -static F_ *init_stack = NULL; +static StgFunPtr *init_stack = NULL; void 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()"); @@ -299,10 +285,10 @@ hs_add_root(void (*init_root)(void)) to the last occupied word */ init_sp = INIT_STACK_BLOCKS*BLOCK_SIZE_W; bd = allocGroup_lock(INIT_STACK_BLOCKS); - init_stack = (F_ *)bd->start; - init_stack[--init_sp] = (F_)stg_init_finish; + init_stack = (StgFunPtr *)bd->start; + init_stack[--init_sp] = (StgFunPtr)stg_init_finish; if (init_root != NULL) { - init_stack[--init_sp] = (F_)init_root; + init_stack[--init_sp] = (StgFunPtr)init_root; } cap->r.rSp = (P_)(init_stack + init_sp); @@ -310,19 +296,39 @@ hs_add_root(void (*init_root)(void)) freeGroup_lock(bd); -#if defined(PROFILING) || defined(DEBUG) + startupHpc(); + // 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"); @@ -337,71 +343,70 @@ hs_exit(void) /* start timing the shutdown */ stat_startExit(); -#if defined(THREADED_RTS) && !defined(mingw32_HOST_OS) + OnExitHook(); + + // Free the full argv storage + freeFullProgArgv(); + +#if defined(THREADED_RTS) ioManagerDie(); #endif /* stop all running tasks */ - exitScheduler(); + exitScheduler(wait_foreign); + + /* run C finalizers for all active weak pointers */ + runAllCFinalizers(weak_ptr_list); -#if defined(GRAN) - /* end_gr_simulation prints global stats if requested -- HWL */ - if (!RtsFlags.GranFlags.GranSimStats.Suppressed) - end_gr_simulation(); +#if defined(RTS_USER_SIGNALS) + if (RtsFlags.MiscFlags.install_signal_handlers) { + freeSignalHandlers(); + } #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 + exitTimer(wait_foreign); -#if defined(PAR) - /* controlled exit; good thread! */ - shutdownParallelSystem(0); - - /* global statistics in parallel system */ - PAR_TICKY_PAR_END(); + // set the terminal settings back to what they were +#if !defined(mingw32_HOST_OS) + resetTerminalSettings(); #endif + // uninstall signal handlers + resetDefaultHandlers(); + /* stop timing the shutdown, we're about to print stats */ stat_endExit(); + /* shutdown the hpc support (if needed) */ + exitHpc(); + // clean up things from the storage manager's point of view. // also outputs the stats (+RTS -s) info. exitStorage(); + /* free the tasks */ + freeScheduler(); + /* free shared Typeable store */ - exitTypeableStore(); + exitGlobalStore(); - /* initialise the stable pointer table */ + /* free linker data */ + exitLinker(); + + /* free file locking tables, if necessary */ +#if !defined(mingw32_HOST_OS) + freeFileLocking(); +#endif + + /* free the stable pointer table */ exitStablePtrTable(); - /* free hash table storage */ - exitHashTable(); +#if defined(DEBUG) + /* free the thread label table */ + freeThreadLabelTable(); +#endif #ifdef RTS_GTK_FRONTPANEL if (RtsFlags.GcFlags.frontpanel) { @@ -413,27 +418,46 @@ hs_exit(void) reportCCSProfiling(); #endif -#if defined(PROFILING) || defined(DEBUG) endProfiling(); -#endif + 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 + +#ifdef TRACING + endTracing(); + freeTracing(); #endif #if defined(TICKY_TICKY) if (RtsFlags.TickyFlags.showTickyStats) PrintTickyInfo(); #endif -#if defined(mingw32_HOST_OS) - shutdownAsyncIO(); +#if defined(mingw32_HOST_OS) && !defined(THREADED_RTS) + shutdownAsyncIO(wait_foreign); #endif - // Finally, free all our storage. - freeStorage(); + /* free hash table storage */ + exitHashTable(); + + // Finally, free all our storage. However, we only free the heap + // memory if we have waited for foreign calls to complete; + // otherwise a foreign call in progress may still be referencing + // heap memory (e.g. by being passed a ByteArray#). + freeStorage(wait_foreign); + +} + +// The real hs_exit(): +void +hs_exit(void) +{ + hs_exit_(rtsTrue); + // be safe; this might be a DLL } // Compatibility interfaces @@ -446,40 +470,32 @@ shutdownHaskell(void) 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 + // we're about to exit(), no need to wait for foreign calls to return. + hs_exit_(rtsFalse); + + if (hs_init_count == 0) { stg_exit(n); -#endif } } +#ifndef mingw32_HOST_OS +void +shutdownHaskellAndSignal(int sig) +{ + hs_exit_(rtsFalse); + kill(getpid(),sig); +} +#endif + /* * called from STG-land to exit the program */ -#ifdef PAR -static int exit_started=rtsFalse; -#endif - void (*exitFn)(int) = 0; void stg_exit(int n) { -#ifdef PAR - /* HACK: avoid a loop when exiting due to a stupid error */ - if (exit_started) - return; - exit_started=rtsTrue; - - IF_PAR_DEBUG(verbose, debugBelch("==-- stg_exit %d on [%x]...", n, mytid)); - shutdownParallelSystem(n); -#endif if (exitFn) (*exitFn)(n); exit(n);