Regarding the more precise GC

[bearophile]

In the main D newsgroup I have seen the two recent threads 
regarding a more precise GC in D. I have two questions about 
that, that seem more fit for D.learn.

1) I have not fully understood the performance and memory 
implications of the more precise GC. In the thread I think I've 
seen a memory overhead in every allocated struct. Is it possible 
to disable this bookkeeping/overhead for smaller programs that 
enjoy/need a GC but probably don't need a precise GC because they 
run only for no more than 30 seconds? Many of my small D programs 
are command-line utilities with a short run-time, but they often 
need a GC.


2) If I have a tagged union, like:


static bool isPointer;

union Foo {
     size_t count;
     int* ptr;
}

In every point of my program I know that inside a Foo there is a 
pointer or a size_t according to the value isPointer (a similar 
case is if I use a single bit tagging inside a size_t to denote 
if it's a pointer or an integral value. The D docs say that in 
the current conservative GC design such pointer tagging with a 
single bit is not allowed if the pointer is to CG-managed memory, 
but the union is allowed. Maybe with the more precise GC even the 
pointer tagging gets possible).

Is it possible to tell to the precise GC every time it performs a 
collection if a Foo contains a pointer to follow, or if it 
instead contains just an integral value to ignore? I think it 
needs to be a function pointer or some kind of callback.

Bye and thank you,
bearophile