Erl_interface's fixed term allocator

[Torbjorn Tornkvist]

> I use erl_free_term() to free each ETERM that I allocate.  Some
> investigation suggests that this is not enough.  Apparently this
> just moves the memory to a "freelist".

Let's see if I remember this correct. The erl_interface
library uses a sort of reference counting system to keep track
of allocated ETERM structs. So if you write:

   ETERM *t_arr[2];
   ETERM *t1;
   
   t_arr[0] = erl_mk_atom("hello");
   t_arr[1] = erl_mk_atom("world");
   t1       = erl_mk_tuple(&t_arr[0],2);

you have created three (3) Erlang terms (ETERM). Now if you
call: erl_free_term(t1) you only free upp the tuple not the
other two ETERM's. To free all the allocated memory, you
would have to call:

   erl_free_term(t_arr[0]);
   erl_free_term(t_arr[1]);
   erl_free_term(t1)

To avoid all these calls to erl_free_term() you can use:
erl_free_compund() instead. It does a "deep" free of
all ETERM's. So the above could be accomplished with:

   erl_free_compund(t1)

Thus, this routine makes it possible for you to write 
in a more compact way where you don't have to remember 
the references to all sub-component ETERM's. 
Example:

   ETERM *list;

   list   = erl_cons(erl_mk_int(36), 
                     erl_cons(erl_mk_atom("tobbe"), 
                              erl_mk_empty_list()));
    ... /* do some work */
   erl_free_compound(list);


Cheers /Tobbe
(Ps. I guess it is obvious that after a call to erl_free_compound(t1)
     in the first example you must not call erl_free_term(t_arr[i])
     (where i = 0 or 1). )