Re: MPS: native comp

["Gerd Möllmann" <gerd.moellmann@gmail.com>]

Andrea Corallo <acorallo@gnu.org> writes:

> Gerd Möllmann <gerd.moellmann@gmail.com> writes:
>
>> Andrea Corallo <acorallo@gnu.org> writes:
>>
>>> If the object was moved and the d_reloc is now updated by MPS I've a
>>> doubt:
>>>
>>> What if our object (say d_reloc[x]) is loaded in a register by the
>>> compiler?  How does the register gets updated by MPS?  In native code we
>>> do this all the time for performance reasons.
>>
>> MPS traces registers and control stacks as ambig roots, so a reference
>> from there makes the corresponding object immovable.
>
> I think I miss few bits to understand MPS:
>
> If stack and registers are scanned I guess MPS has to stop the mutator
> thread no?  

Yes.

> In the moment after the mutator restarts after the scan other ambig
> roots might appear, so how can such moving collection be done in a
> parallel fashion?

The exact algorith MPS implements I don't know either. The docs include
some design documents, but I haven't read them all, and some I didn't
understgand because there was some context missing.

A number of possible algorithms that could be used are described in the
literature, or one could glance at existing GCs for V8, for example.
Hard to read though, for me at least.

> Also if this mechanism (I don't fully understand ATM) is working the
> issue I mentioned of values being kept in registers should be a non
> issue.  Code we generate from Lisp is not very different from the one we
> compile form C (we still have registers spill/fills etc).

Yes, I think the same. It's just like some C code running.

>> Haha, I hadn't even remotely occurred to me that you would emit a
>> comment with the name :-). That makes things a lot easier. 👍
>
> To survive I had to find my way somehow :)

:-)

>
>>> I think the easiest is to to make objects loaded from native code non
>>> movable.  Is this possible with MPS? What would be the downside of this?
>>> They are very rarely collected anyway.  WDYT?
>>
>> I'd personally prefer to trace comp units in the usual way for Lisp
>> objects, i.e. the fix_comp_unit.
>>
>> Main reason is simplicity. The tracing function is super simple, we only
>> have to identify where in the comp unit data structure, or dylib,
>> references exist that have to be traced. Registers/stack are not a
>> problem (see above).
>>
>> Other reasons, not so important, but anyway, is reducing the number of
>> roots. Every root adds to what MPS has to do. And ambig roots make
>> objects immovable, which is somewhat against the spirit of a copying
>> collector.
>>
>> Just my personal opinion, of course.
>
> Well other than spirit and possibly simplicity we should evaluate if
> (and in case how much) is the cost to have this objects movable vs
> non-movable.

Sure.

For me personally the most important aspect is interactive user
experience. Let's say complaints about GC pauses are not entirelly
unheard of ;-). I even have one myself: In an Org file, with my init.el,
GC kicks in every 5 lines with C-n/C-p (something font/jit-locking
produces heaps of garbage). It's unbearable, and that's on my old
battlehorse MBPro with i7 from 2013 which I used for years for C++
development in Linux VMs just fine :-/.

> The starting point for me is that this is a very special kind of object
> class we know in advance is very rarely (if ever) collected, so would be
> a pity to not consider this in the definition of the GC strategy
> (assuming is an option).

MPS is also generational, i.e. objects eventually move to older
generations which are less frequently collected. Haven't played with
that knob though. Atm, there are 2 generations.

If the CUs are in the loaded pdump, they won't be collected anyway, of
course. How that works best I have still to figure out, but I didn't get
a chance yet :-).

And the pdump is also an aspect all in in itself...
And in general, lots of things could be tried...