Re: [Caml-list] Finding "lost" references to OCaml heap values

[Gerd Stolpmann <info@gerd-stolpmann.de>]

[-- Attachment #1: Type: text/plain, Size: 2565 bytes --]

Am Dienstag, den 06.10.2015, 15:16 +0100 schrieb Richard W.M. Jones:
> On Tue, Oct 06, 2015 at 02:43:42PM +0100, Richard W.M. Jones wrote:
> > 
> > I guess I have two questions:
> > 
> > (1) Is calling Gc.compact () guaranteed to call the finalizer of any
> > object which is no longer reachable, under all circumstances?  Or
> > would there be some case where it wouldn't be called?
> > 
> > (2) I have a large mixed OCaml / C program[a] where somehow calling
> > Gc.compact isn't calling the destructor of a (very) large object.
> > Manual code inspection has not revealed anything so far --
> > superficially it appears we are not holding any references to the
> > object.  Is there any method / library / tool that can inspect the
> > OCaml heap and find references to an object?
> 
> Always good to explain these things, because the act of explaining it
> has allowed me to work out why (2) is happening now.
> 
> The reason is because I was registering a global root from the C heap
> pointing to the handle, and of course this prevents the handle from
> being unreferenced.
> 
> This does, however, raise another question:
> 
> (3) I want to have a C heap 'value' pointing to an OCaml value, in
> such a way that if the OCaml value moves around, the C value gets
> updated to point to the new location.  I was using a global root
> for this purpose, but it seems like global roots really have two
> purposes:
> 
>   (i) To keep the C value updated if the OCaml value moves.
> 
>   (ii) To act as a global root, preventing the value from being freed.
> 
> Is there a "weak" global root, that has property (i) but not property (ii)?

There is nothing like that in the C API of the OCaml FFI. What you can
do is to keep only a symbolic reference to the OCaml value from the C
struct (i.e. if it is the k-th such value just store the number k). The
mapping from k to the OCaml value can be done with a weak hash table.
For finalizing this you need to use Gc.finalize.

All in all this is quite complicated. I guess it's only worth it if the
memory management really needs to be fully-automatic.

Gerd

> Rich.
> 
> -- 
> Richard Jones
> Red Hat
> 

-- 
------------------------------------------------------------
Gerd Stolpmann, Darmstadt, Germany    gerd@gerd-stolpmann.de
My OCaml site:          http://www.camlcity.org
Contact details:        http://www.camlcity.org/contact.html
Company homepage:       http://www.gerd-stolpmann.de
------------------------------------------------------------


[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 473 bytes --]