Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] register_global_root, malloc, etc.
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Alexander V. Voinov <avv@q...>
Subject: Re: [Caml-list] register_global_root, malloc, etc.
Hi All,

Xavier Leroy wrote:
> 
> [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.

I can't understand who will delete `foo *', allocated via `foo *p = new
foo'? As I understood from the manual, Custom_tag is the only way to
assign free_foo with the resulting Caml object. And I'm surprised by
your statement that after calling free_foo the program can still use
this reference. This sounds as if I bought a train ticket but the
railway station clerk warned me that despite of the fact that I paid
there still is a risk that my seat will be sold to somebody else :-).

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