Re: [Caml-list] register_global_root, malloc, etc.

[Xavier Leroy <Xavier.Leroy@inria.fr>]

[I see that your message was left unanswered.  Hope the following late
answer will help.]

> If I'm writing a module in C and want to have an abstract type that
> corresponds to that struct (allocated with new/malloc/etc. from C),
> is the following code correct?
> 
> CAMLlocal1(result);
> foo *p = new foo;
> p->callback = Val_unit;
> register_global_root(&(p->callback));
> result = alloc_small(1,Abstract_tag);
> Field(result,0) = (value)p;
> CAMLreturn(result);
> 
> Then, later, I can just assign another closure passed to a C function (and CAMLparam'ed) to p->callback without worrying about it, like this:
> 
> value set_callback( value fooval, value callback )
> {
> 	CAMLparam2(fooval,callback);
> 	foo *p = (foo *)Field(fooval,0);
> 	p->callback = callback;
> 	CAMLreturn(Val_unit);
> }
> 
> Is that correct?

Yes.

> Should I use Custom_tag and register all the finalization functions
> and whatnot for my abstract type, or is Abstract_tag good enough
> assuming I've got a free_foo function that users of the module are
> supposed to call to deallocate the abstract type?  free_foo should
> call remove_global_root before deleting the memory, right?  But I
> don't need to do anything to explicitly delete the callback or the
> Abstract_tag block that was passed in since the GC will handle it?

You're 100% correct.  The only advantage of Custom_tag over
Abstract_tag is that finalization can be handled by the GC instead of
by the user (via free_foo).  GC-based finalization is safer in the
sense that you're certain that the object cannot be reached again by
Caml code.  With user-managed finalization, there is always the risk
that the program will call free_foo, then still use the "foo" value
afterwards.

- Xavier Leroy
-------------------
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