Unify GC class and Gcx struct

For some unknown reason, the GC implementation was divided in 2, a GC
class and a Gcx struct. This patch unify them in a GC struct. Only code is
moved (and stats are adjusted).

Remove obsolete unused variables

Make heap precise scanning optional

Now D_GC_OPTS accepts a new boolean option: conservative. When true, the
heap is scanned conservatively, even when type information is available.
The option defaults to false.

opts: Fix parsing a single boolean option without args

stats: Refactor code to avoid duplication

stats: Add more type information to malloc logging

stats: Log the pointer to the allocated memory

Make heap scanning precise

This patch[1] is based on the patch provided by Vincent Lang (AKA wm4),
which was based on a patch[2] by David Simcha, both published in the bug
3463[3]. The patch needs a patched Tango runtime (which is part of the
patch[1] for the GC) and a patched[4] DMD to work.

The patched DMD passes type information about pointer locations to
allocations, a PointerMap. The PointerMap has a member bits, which is an
array of size_t elements. The first element is the T.sizeof / size_t,
where T is the type being allocated. The next elements are bitmask
indicating words that should be scanned. After that, the next elements
store another bitmask with the information about pointers. A moving
collector could change the value of words marked as pointers, but not
words that should only be scanned (that words are not guaranteed to be
pointers), so a block could only be moved if it's only reachable by
pointers. The pointers information is not used yet by this patch, only the
scan bits are used.

The precise scanning algorithm is extremely simple, and needs a lot of
optimization, this patch was kept simple on purpose. Optimizations will
follow in separated patches.

A pointer to the type information is stored at the end of the allocated
blocks (only if the blocks should be scanned, blocks marked with NO_SCAN
don't need the type information). This wastes some space, and space that
then have to be scanned, which tends to decrease the performance quite
a bit.

[1] http://d.puremagic.com/issues/attachment.cgi?id=696
[2] http://d.puremagic.com/issues/attachment.cgi?id=489
[3] http://d.puremagic.com/issues/show_bug.cgi?id=3463
[4] http://d.puremagic.com/issues/attachment.cgi?id=700

Improve variable names for block attributes

Add statistics collection

Statistics meassure this metrics.

For each collection:

* Time spent in the malloc that triggered the collection.
* Time spent with the world stopped.
* Time spent doing the collection.
* Memory info before and after the collection: used, free, overhead and
  wasted memory. Used is the memory used by the mutator, free is the
  memory the mutator can request, overhead is the memory used by the
  collector itself and wasted is memory that is not used by either the
  mutator or collector and that can't be requested by the mutator either.

For each malloc() call:

* Time spent.
* Amount of memory requested.
* Attributes of the requested memory.
* A flag to tell if this call triggered a collection.

Statistics collection is controlled via the D_GC_OPTS environment
variable. To collect malloc statistics, use the option
malloc_stats_file, the value is the path to the file where to store the
malloc statistics (the contents will be replaced). To collect garbage
collection statistics, use the option collect_stats_file, the value is
the path to the file where to store the malloc statistics (the contents
will be replaced). The generated files are in CSV format and have
headers that make them self explanatory.

Make the GC configurable at runtime via env vars

The GC offers a couple of options to debug memory problems, but they are
selectable only at compile-time. Being the GC part of the compiler
runtime, is not very common for the user to recompile the GC when it has
a memory problem, so making this option available always is very
desirable.

This patch allows configuring the GC via environment variables. 4 options
are available: sentinel, mem_stomp, verbose and log file. Only the first
2 are implemented right now.

For example, to check a program using memory stomping and a sentinel, you
can run it like this (using sh):

$ D_GC_OPTS=mem_stop=1:sentinel

As you can see, the value is optional for boolean options.

Call memset() only for large enough chunks of data

Calling memset() for small memory chunks can be expensive compared to
a simple loop.

Use a DynArray to store the memory pools

Use a few more initial elements by default

Moving from 4 to 16 can improve the performance a little for short lived
programs.

Use a custom dynamic array to store roots and ranges

Remove Gcx destructor

There is no point on freeing memory as the OS will do it for us.

Comment why we avoid calling free with null

Even when free() can be called with a null pointer, the extra call might
be significant. On hard GC benchmarks making the test for null in the GC
code (i.e. avoiding the free() call) can reduce the GC time by almost ~5%.

Remove debug LOGGING code

This code will be superseded by the statistic collection code, and it was
unmantained and very probably broken (for example, the file and line
number was never filled in).

Add VIM modeline to avoid style errors

Use tango bindings to C standard library functions

As we need to use more libraries it became less practical to maintain our
own set of bindings, and since the GC only works with Tango, it makes
sense to just use Tango bindings.

Remove PRINTF debug statements

Fix minor coding style issues

Use more explicit imports

Add missing import for DMD

Move the modules to package rt.gc.cdgc

Tango 0.99.9 uses this package scheme, so we follow it for easier
integration.

Minor formatting fixes

Add weak reference support for Tango 0.99.9

Remove the MULTI_THREADED version

This will be an inherently concurrent GC, so having a non-threaded version
of it makes no sense. Even more, I think the non-threaded doesn't even
compile.

Remove (un)committed pages distinction

This distinction is only made by Windows, and adds an extra complexity
that probably doesn't worth it (specially for other OSs, where this adds
a little overhead too, in both space and time).

Other OSs (like Linux) even do all the committing automatically, under the
hood, see:
http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=blob;\
f=Documentation/vm/overcommit-accounting;hb=HEAD

Make allocation functions that can fail return bool

There is no point on returning int, since no error code is returned, just
failure or success.

Fix spacing style

Declare public allocation API

Declare the public API and move comments to the declaration, to avoid
duplication and let ddoc document the functions for all versions.

Remove valloc() allocation method

Almost any system that support valloc() supports mmap(), and being
a deprecated function, it makes not much sense to maintain it as an
allocation method.

Make sure MAP_ANON exists when using mmap()

Remove commented out code

Remove Tango dependency

To avoid Tango dependency, we need to write our own C-API interface. This
is done in the new gc.libc module. In the future, maybe this module will
use Tango or Phobos accordly, but for now we stay free of dependencies (at
the expense of some extra work).

Remove debug version THREADINVARIANT

The code seemed to be broken, since the self thread ID was stored at
initialization and then asserted that the GC always run from that thread,
which seems far from reality (the GC can be invoked by any thread).

The PRINTF version now doesn't print the current thread ID either.

Rename module names to make more sense

Make gc a package

Add a "clean" target to the Makefile

Put built stuff in a separated build directory

Add a wrapper script to run programs using CDGC

Remove redundant "private" from import statements

Since a long while ago, imports are "private" by default.

Concurrent D Garbage Collector initial commit

The Concurrent D Garbage Collector (CDGC) is based on the "basic" garbage
collector from the Tango runtime. This first commit is a copy of this GC,
as it is in Tango 0.99.8.

The CDGC is designed only for Linux, at least for now.