10:07 <antocuni> https://discuss.python.org/t/concerns-about-pep-620-hide-implementation-details-from-the-c-api/15827/18?u=antocuni

10:08 <antocuni> this is an interesting post, it contains a lot of stuff that pybind11 needs to be able to query on a type object. We should probably think how to offer the same functionality in HPy

10:12 <phlebas> antocuni: we have added something like this for the numpy port already, as a kind of "preliminary api"

10:12 <phlebas> only for checking the slot function pointer so far, but if we allow that, we might as well allow retrieving the pointer

10:13 <phlebas> since that was originally provided by the user anyway

10:13 <antocuni> "the slot function pointer"? What do you mean?

10:14 <phlebas> i thought you're talking about that they want to use `PyType_GetSlot`?

10:19 <antocuni> ah ok, yes

10:19 <antocuni> I just didn't understand what you meant

16:02 <antocuni> pff, calling tp_traverse from the PyPy's GC custom tracer is a mess

16:08 <antocuni> I think I want something like this: https://paste.openstack.org/show/b5lFYk8FsLtDbKybEkmo/

16:08 <antocuni> i.e., the pypy GC calls hpy_customtrace, which calls tp_traverse, which calls _trace_one_field, which finally calls gc._trace_callback

16:09 <antocuni> the hard part is to make RPython happy

16:09 <antocuni> I think there are at least 2 problems:

16:10 <antocuni> 1. hpy_customtrace is @specialized on the callback, so I need to create many instances of ll_trace_one_field, one per each callback. I suppose I can somehow do it by adding this feature to get_llhelper()

16:12 <antocuni> 2. how do I pass "gc" and "arg" from hpy_customtrace to _trace_one_field? I cannot use an RPython tuple because I cannot allocate anything using the GC; if I were in C, I would allocate a custom struct on the stack, but in RPython it's not so easy

16:14 <antocuni> I don't think we have any RPython support for calling alloca(), do we?

16:14 <antocuni> what a mess

16:15 <antocuni> cfbolz, arigato, ronan, fijal, mattip: do you have any idea?

16:17 <antocuni> for reference, this is the branch I'm playing with: https://foss.heptapod.net/pypy/pypy/-/tree/branch/hpy-0.0.4-hpyfields

16:18 <cfbolz> antocuni: store it into fields on the GC?

16:18 <antocuni> and this is the tentative diff which I have for the customtracer (in this diff, it always assume there are to HPyFields at offsets 0 and 8): https://paste.openstack.org/show/bdmlRua7zw9GbAwDXbt3/

16:20 <antocuni> cfbolz: so basically, I would pass "gc" as the arg of trace_one_field, and fish gc.original_arg from there?

16:20 <antocuni> it looks hacky but it might work

16:21 <antocuni> there is one more problem. Inside trace_one_field, I receive "arg" which is a void*, and I need to cast it to the correct RPython type of "gc" before calling gc._trace_callback

16:24 <antocuni> uhm, I might have to use annlowlevel.cast_object_to_ptr and cast_base_ptr_to_instance & friends?

16:30 <antocuni> I also don't understand whether 'gc' is a real object or a prebuilt constant similar to space

16:31 <antocuni> (hoorray for RPython clarity)

16:33 <antocuni> I'd expect that gc is a prebuilt, but looking at the generated C code I see that there is an actual object of type "struct pypy_rpython_memory_gc_incminimark_IncrementalMiniMarkG0*" which is passed around

16:55 <cfbolz> antocuni: it's an instance

16:55 <cfbolz> Can't be pre-built because it has mutable attributes

16:57 <antocuni> uhm, I think that prebuilt instances can still be mutable, cannot them?

16:58 <antocuni> e.g., hpy's handlemanager is a prebuilt and it owns the list of handles

17:12 <cfbolz> antocuni: ah, I might be mixing up prebuilt and frozen

17:12 <cfbolz> but anyway, it's not like the space, which is frozen

17:13 <antocuni> right

17:13 <antocuni> anyway, not so important for my problem at hand, but I was curious

17:23 <cfbolz> antocuni: why do you need a concrete instance?

17:24 <cfbolz> Isn't a gcref enough for the GC?

17:24 <antocuni> I need a concrete instance of the 'gc' object

17:24 <cfbolz> Ah

17:24 <antocuni> to call gc._trace_callback

17:24 <cfbolz> That is very difficult 😅

17:25 <antocuni> I know

17:25 <antocuni> things which are trivial in C are very difficult in RPython 😤

17:25 <cfbolz> might even be not supported atm

17:25 <cfbolz> because so far we only cast GC instances

17:25 <cfbolz> to gcref

17:26 <antocuni> can't I use annlowlevel.cast_instance_to_base_ptr() and back?

17:33 <cfbolz> antocuni: maybe it works, just saying that you would be the first to try this

17:34 <antocuni> "hooray"

17:34 <antocuni> and everything is made much more difficult because it's hard to unit test

17:35 <antocuni> I don't even know where to start to write a test which can be run before translation

17:36 <cfbolz> antocuni: hmmm, maybe you could do this differently

17:37 <cfbolz> You could have a new rpython op gc_get_instance that the GC transformer turns into the constant

17:37 <antocuni> uhm right

17:37 <antocuni> this could be simpler

17:38 <antocuni> this way I don't even need to hack to pass two arguments to the callback, because one will be sufficient

17:39 <cfbolz> Me too