GitLab

  
This patch implements pointer tagging as per our ICFP'07 paper "Faster
laziness using dynamic pointer tagging".  It improves performance by
10-15% for most workloads, including GHC itself.

The original patches were by Alexey Rodriguez Yakushev
<mrchebas@gmail.com>, with additions and improvements by me.  I've
re-recorded the development as a single patch.

The basic idea is this: we use the low 2 bits of a pointer to a heap
object (3 bits on a 64-bit architecture) to encode some information
about the object pointed to.  For a constructor, we encode the "tag"
of the constructor (e.g. True vs. False), for a function closure its
arity.  This enables some decisions to be made without dereferencing
the pointer, which speeds up some common operations.  In particular it
enables us to avoid costly indirect jumps in many cases.

More information in the commentary:

http://hackage.haskell.org/trac/ghc/wiki/Commentary/Rts/HaskellExecution/PointerTagging

We now have a section that describes what hs_exit() does (including
the "wait for foreign calls to return" behaviour), and more
documentation on creating libraries of Haskell code.  I also imported
the section "Beware of DllMain()!" from the haskell.org wiki, with
some minor editing.

This includes automatically adding --build=i386-unknown-mingw32 and
--with-gcc to ./configure, and disabling -j2 (see #1559).

Also: you can now say 

  CPUS=3 ./validate

and the script will pass -jN to make (where N = $CPUS + 1).  In the
future, when we fix #1558, it can pass THREADS=N to the testsuite, too.

Now we don't wait for outstanding IO requests when shutting down at
program exit time, but we still wait when shutting down a DLL (via
hs_exit()).  There ought to be a better way to do this, but
terminating the threads forcibly is not a good idea (it never is: the
thread might be holding a mutex when it dies, for example).

I plan to add some docs to the user guide to describe how to shut
down a DLL properly.

This is pertinent to #1177.  When shutting down a DLL, we need to be
sure that there are no OS threads that can return to the code that we
are about to unload, and previously the threaded RTS was unsafe in
this respect.

When exiting a standalone program we don't have to be quite so
paranoid: all the code will disappear at the same time as any running
threads.  Happily exiting a program happens via a different path:
shutdownHaskellAndExit().  If we're about to exit(), then there's no
need to wait for foreign calls to complete.

  
I didn't actually fix this to respect Haskell 98, instead I changed it
to follow the proposal for Haskell':

http://hackage.haskell.org/cgi-bin/haskell-prime/trac.cgi/wiki/QualifiedIdentifiers

Rationale:

  - We didn't respect Haskell 98 with respect to qualified symbols either
  - The Haskell' change makes things much cleaner
  - Obeying the Haskell 98 spec literally has some unintended
    consequences (e.g. M.where must lex as "M.wher" "e")
  - Any programs that compiled before this change and do not compile
    after it were illegal according to Haskell 98 anyway.

It looks like this was an experiment that accidentally got committed,
somewhere between 6.0 and 6.2.

We were recompiling the .hs-boot files each time, as we were never
writing out the compilation results.

The problem of the splitter was that it re-emitted section directives
for every dynamic label found. The following was torn apart

.symbol_stubs
.indirect <symbol>
L_<symbol>$stub: 
	jmp *...
L_<symbol>$stub_binder:
	..somebinding code..

into

.symbol_stubs
.indirect_symbol <symbol>
L_<symbol>$stub: 
	jmp *...
.symbol_stubs <--- NEW
L_<symbol>$stub_binder:
	..somebinding code..

This is incorrect as the Mac OS assembler enforces that every new code
section that goes into .symbol_stubs is associated with the linker
directive .indirect_symbol. This sanity check is obviously violated
when we reemit .symbol_stub in the splitter. The solution is to ignore
everything that ends with $stub_binder as new label, and chuck it into
a single label for $stub.

Also the splitter has to recognize .section __DATA... for the lazy_ptr
indirection symbol. Adds a reminder to PositionIndependentCode.hs to
take care of the splitter when the code generation is changed.

This should not affect -fvia-c as the code generated by the C compiler
is entirely different.