Hi All,

Jacques Garrigue wrote:
> Either these values are long ints, and you can just copy them, or they
> are pointers, and you just do as I explained.
> 
> value my_func(value a, value b)
> {
>      value *loca = (value*)malloc(sizeof(value));
>      value *locb = (value*)malloc(sizeof(value));
>      *loca = a; *locb = b;
>      register_global_root(loca);
>      register_global_root(locb);
> 
>      ....
> }
> 
> Now you can put loca and locb directly in you C data structure, the
> real data being accessed by *loca, *locb.
> 
> Of course, don't forget that you must unregister your global roots
> before freeing loca  and locb.

I've played a bit with this, and I have an observation that huge amount
of time is spent on remove_global_root(a). 

I will describe the problem, to let you better understand to context. I
have an implementation of B+-tree, with threading, allowing duplicates
and logarithmic access to the item number. Of course it would be fun to
reimplement it in OCaml, but I have enough fun besides this, and enough
serious tasks for which specifically I started to consider OCaml; also,
I'd like to see on this example how much could I get in the interaction
between C and OCaml; next, the module is tested and used for years, and
I see no point to duplicate the work. If successful, I'd like to make it
available for OCaml community. 

I store arbitrary OCaml objects in the nodes of the tree, using the
advice quoted above. And I see that the performance of an application is
very different with and without remove_global_root(a). Am I doing
something wrong (besides the very idea of building a complex C
structure, containing lots of OCaml objects; let's assume that the idea
is justified in this or that case)?

Thank you in advance

Alexander
-------------------
Bug reports: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr