Re: MPS: native comp

[Andrea Corallo <acorallo@gnu.org>]

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?  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?

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).

>>> Next strategy or tactic, I think, could be to produce a C file for
>>> macroexp.eln, and see where the symbol appears. I would imagine that I
>>> can deduce from the text representaton of the constants in C what index
>>> correspondons to the symbol, and then see if it is used in surprising
>>> ways. Maybe. WDYT?
>>
>> You'll probably see what I mentioned above.  At the beginning of the
>> compiled function we load in regular variables the lisp objects from
>> d_reloc so GCC leverage the register allocater and keep in registers.
>
> Yep, I see that.
>
>> For instance we do exactly this 'byte-compile-form-stack' and others
>> here:
> ....
>>   /* byte-compile-form-stack */
>>   slot_3 = d_reloc[(long long)1];
>
> 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.

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).

Thanks

  Andrea