GitLab

We should really delete the main thread in a deadlock situation,
otherwise if we somehow recover it might stay in the system
indefinitely.

Change the story about POSIX headers in C compilation.

Until now, all C code in the RTS and library cbits has by default been
compiled with settings for POSIXness enabled, that is:
   #define _POSIX_SOURCE   1
   #define _POSIX_C_SOURCE 199309L
   #define _ISOC9X_SOURCE
If you wanted to negate this, you'd have to define NON_POSIX_SOURCE
before including headers.

This scheme has some bad effects:

* It means that ccall-unfoldings exported via interfaces from a
  module compiled with -DNON_POSIX_SOURCE may not compile when
  imported into a module which does not -DNON_POSIX_SOURCE.

* It overlaps with the feature tests we do with autoconf.

* It seems to have caused borkage in the Solaris builds for some
  considerable period of time.

The New Way is:

* The default changes to not-being-in-Posix mode.

* If you want to force a C file into Posix mode, #include as
  the **first** include the new file ghc/includes/PosixSource.h.
  Most of the RTS C sources have this include now.

* NON_POSIX_SOURCE is almost totally expunged.  Unfortunately
  we have to retain some vestiges of it in ghc/compiler so that
  modules compiled via C on Solaris using older compilers don't
  break.

tiny layout wibble

Innocent changes to resurrect/add 64-bit support.

Add a compacting garbage collector.

It isn't enabled by default, as there are still a couple of problems:
there's a fallback case I haven't implemented yet which means it will
occasionally bomb out, and speed-wise it's quite a bit slower than the
copying collector (about 1.8x slower).

Until I can make it go faster, it'll only be useful when you're
actually running low on real memory.

'+RTS -c' to enable it.

Oh, and I cleaned up a few things in the RTS while I was there, and
fixed one or two possibly real bugs in the existing GC.

Try doing a major GC before declaring that we're deadlocked, since
there might be finalizers waiting to run that can unblock the system.

Noticed by: Manuel.

Changes to support bootstrapping the compiler from .hc files.  It's
not quite working yet, but it's not far off.

  - the biggest change is that any injected #includes are now placed in
    the .hc file at generation time, rather than compilation time.  I
    can't see any reason not to do this - it makes it clear by looking at
    the .hc file which files are being #included, it means one less
    temporary file at compilation time, and it means the .hc file is more
    standalone.

  - all the gruesomeness is in mk/bootstrap.mk, which handles building
    .hc files without a ghc driver.

-*- outline -*-
Time-stamp: <Thu Mar 22 2001 03:50:16 Stardate: [-30]6365.79 hwloidl>

This commit covers changes in GHC to get GUM (way=mp) and GUM/GdH (way=md)
working. It is a merge of my working version of GUM, based on GHC 4.06,
with GHC 4.11. Almost all changes are in the RTS (see below).

GUM is reasonably stable, we used the 4.06 version in large-ish programs for
recent papers. Couple of things I want to change, but nothing urgent.
GUM/GdH has just been merged and needs more testing. Hope to do that in the
next weeks. It works in our working build but needs tweaking to run.
GranSim doesn't work yet (*sigh*). Most of the code should be in, but needs
more debugging.

ToDo: I still want to make the following minor modifications before the release
- Better wrapper skript for parallel execution [ghc/compiler/main]
- Update parallel docu: started on it but it's minimal [ghc/docs/users_guide]
- Clean up [nofib/parallel]: it's a real mess right now (*sigh*)
- Update visualisation tools (minor things only IIRC) [ghc/utils/parallel]
- Add a Klingon-English glossary

* RTS:

Almost all changes are restricted to ghc/rts/parallel and should not
interfere with the rest. I only comment on changes outside the parallel
dir:

- Several changes in Schedule.c (scheduling loop; createThreads etc);
  should only affect parallel code
- Added ghc/rts/hooks/ShutdownEachPEHook.c
- ghc/rts/Linker.[ch]: GUM doesn't know about Stable Names (ifdefs)!!
- StgMiscClosures.h: END_TSO_QUEUE etc now defined here (from StgMiscClosures.hc)
                     END_ECAF_LIST was missing a leading stg_
- SchedAPI.h: taskStart now defined in here; it's only a wrapper around
              scheduleThread now, but might use some init, shutdown later
- RtsAPI.h: I have nuked the def of rts_evalNothing

* Compiler:

- ghc/compiler/main/DriverState.hs
  added PVM-ish flags to the parallel way
  added new ways for parallel ticky profiling and distributed exec

- ghc/compiler/main/DriverPipeline.hs
  added a fct run_phase_MoveBinary which is called with way=mp after linking;
  it moves the bin file into a PVM dir and produces a wrapper script for
  parallel execution
  maybe cleaner to add a MoveBinary phase in DriverPhases.hs but this way
  it's less intrusive and MoveBinary makes probably only sense for mp anyway

* Nofib:

- nofib/spectral/Makefile, nofib/real/Makefile, ghc/tests/programs/Makefile:
  modified to skip some tests if HWL_NOFIB_HACK is set; only tmp to record
  which test prgs cause problems in my working build right now

ASSERT in updateWithIndirection() that we haven't already updated this
object with an indirection, and fix two places in the RTS where this
could happen.

The problem only occurs when we're in a black-hole-style loop, and
there are multiple update frames on the stack pointing to the same
object (this is possible because of lazy black-holing).  Both stack
squeezing and asynchronous exception raising walk down the stack and
remove update frames, updating their contents with indirections.  If
we don't protect against multiple updates, the mutable list in the old
generation may get into a bogus state.

A good bug: detectBlackHoles wasn't checking for ThreadRelocated,
which is why we sometimes get "no threads to run: infinite loop or
deadlock?" when we should get a NonTermination exception.

To be merged into the 4.08 branch.

check for ThreadRelocated when unblocking a thread blocked on
delivering an async exception.

Bite the bullet and make GHCi support non-optional in the RTS.  GHC
4.11 should be able to build GHCi without any additional tweaks now.

- the Linker is split into two parts: LinkerBasic.c, containing the
  routines required by the rest of the RTS, and Linker.c, containing
  the linker proper, which is not referred to from the rest of the RTS.
  Only Linker.c requires -ldl, so programs which don't make use of the
  linker (everything except GHC, in other words) won't need -ldl.

Remove all vestiges of INTERPRETER and __HUGS__.

Remove now-unnecessary markCAFs().

Add a CAF list for GHCI.

Retaining all looked-up symbols in a list in the interpreter was the
Wrong Thing To Do, since we can't guarantee that the transitive
closure of this list points to all the CAFs so far evaluated (the
transitive closure gets smaller as reachable CAFs are evaluated).

A Better Thing To Do is just to retain all the CAFs.  A refinement is
to only retain all CAFs in dynamically linked code, which is what this
patch implements.

this isn't legal C, apparently:

	switch (e) {
	label:
	}

without at least one statement between the label and the end block.

Evaluator.h ---> Interpreter.h

Add info tables to do compiled->interpreted returns and vice versa.
Rename various stuff from ...Hugs... to ...Interp...

merge recent changes from before-ghci-branch onto the HEAD

Set tso->link to END_TSO_QUEUE in resumeThread.  This is probably
harmless, but it can trigger an assertion failure later on in the
scheduler.

Change the names of several RTS symbols so they don't potentially
clash with user code.  All the symbols that may clash now have an
"stg_" prefix.

merge before-ghci -> before-ghci-branch-merged into the ghc
(non-compiler) parts of the tree.

debugging output wibbles

Change the way threadDelay# is implemented.

We now use a list of sleeping threads sorted in increasing order by
the time at which they will wake up.  This avoids us having to
traverse the entire queue on each context switch.

Fix a problem where ^C wasn't recognised while waiting for I/O.

Make the TSO structure shorter by 2 words:

	- remove splim.  It was always equal to &(tso->stack) +
	  RESERVED_STACK_WORDS.

	- make two enum fields 16 bits each instead of 32.

Minor cleanups to a few closure types: we don't use StgPtr in
Closures.h anymore.

Implement +RTS -C<n>, the context switch interval flag.  This was
previously advertised in the usage message, but there was a note in
the Users' Guide stating that it didn't work.  Anwyay, I'm going to
consider it a bug and backport to 4.08.1.

Changed __MINGW32__ to mingw32_TARGET_OS to cope with latest mingwin.

Set the context switch flag to zero when running a new thread; the
timer interrupt now initiates a context switch.

remove extra \n in debug message

Detect threads that are blocked on themselves (i.e. black holed), and
raise NonTermination exceptions.  We only do this when the system is
deadlocked, so as not to introduce unnecessary overhead in the normal
case.

raisezh_fast now handles uncaught exceptions cleanly.  The affected
thread is marked as Killed, and if it is a main thread then
rts_evalIO() will return ThreadKilled as it should.

Reduce number of warnings and raise chances of successful compilation
when *not* building an interpreter :-)

Clean up the runtime heap before deleting modules (and, currently, after
every evaluation) so that the combined system can safely throw away
modules and info tables without creating dangling refs from the heap.

Ensure that when Hugs decides to unload a module (nukeModule()), there are
no closures anywhere in the system which refers to infotables defined
in that module.  That means reverting all CAFs and doing a major GC
prior to deleting the module.  A flag is used to avoid redundant GCs.

Restore deadlock detection code commented out by a certain
Mr. H. W. Loidl, and fix up some of the debugging output while I'm here.

TSOs now belong to CCS_SYSTEM.

Restore debugging support that disappeared when the latest parallel
stuff was committed.

Remove unnecessary #include.