Carmack about static analysis

[deadalnix]

Le 26/12/2011 05:23, Andrei Alexandrescu a écrit :
> On 12/25/11 8:56 PM, deadalnix wrote:
>> Le 25/12/2011 05:27, Andrei Alexandrescu a écrit :
>>> Got the GC book this morning, already read 2.5 chapters :o).
>>>
>>>
>>> Andrei
>>>
>>
>> You'll find that you can do a lot when GC is aware of immutability (in
>> functionnal languages, most things tends to be immutable).
>>
>> In the actual state of druntime, the GC is bad, but worse, cannot be
>> imporoved to take advantage of this, and never will unless a major
>> changement is done in GC interface.
>
> What changes do you have in mind?

I think GC should be aware of immutable/shared on type qualifier.

Thread lcoal can be collected in a given thread without caring about 
others. immutable can be used as great advantage to collect concurrently.

>
> I've gone through a larger portion of the book and one thing has become
> very clear to me: we must improve the precision of the collector. This
> would be a gating feature towards taking the GC pretty much anywhere.
>
> As a first step, we must make all allocations except stack type-aware,
> and leave only the stack to be imprecise.
>

I dpo agree. However, this will generate a lot of code bloat. This seems 
to be an issue for many people (see topic on static this and executable 
size for more on that).

This tell us that we need a way to choose between GC. (just like JVM does).

For swap friendlyness, we can separate memory blocks that may contains 
pointer and the ones that cannot. If something is swapped, the GC 
soesn"t need to go throuw it and generate a huge amount of (slow as 
hell) IO.

For the same reason, we may want to use different memory blocks for TLS 
of each thread. If a thread is sleeping and swapped you don't want an 
working thread to prevent this memory to go on swap. The exemple or 
Chrome browser on a notebook is very explicit on that point : it has a 
huge memory footprint and will swap almost inevitably on thoses 
machines. However, it keep being fast because each tab has its own 
memory pool and a tab that hasn't the focus can be swapped almost 
completely. Firefox has a smaller memory fooprint, however, users 
complains more about its memory consuption. Because they are not aware 
of want is really different. Firefox consume less memory, but is way 
less cache friendly and slow down dramatically when it has to swap.

This is a big topic, and we may want to start a topic on that point 
specifically instead of hijacking this thread.