Re: Creating tagged records with C "malloc" rather than Ada "new"

[Robert A Duff <bobduff@shell01.TheWorld.com>]

news01+Steven.Murdoch@cl.cam.ac.uk (Steven Murdoch) writes:

> However I think I can simplify this by allocating space for the
> tagged record in Lua, and hence it will deallocate this space at
> the right time. I would like to know if this is possible to do this
> reliably, and if it is relativly safe,

You should look at RM-13.11, "Storage Management".  You can declare your
own storage pool type.  The Allocate operation could call Lua.
The Deallocate operation could do nothing (which might be appropriate if
you're doing garbage collection).

But there are lots of other issues related to GC.  I don't know anything
about Lua, but I don't see how Lua can know where all the pointers are.
So does it do so-called "conservative" GC?

> The code I am proposing would look something like as follows:
> 
> C:
> /* Actually part of Lua, but this is equivalent */
> void *allocate(int size) {
>         return malloc(size);
> }
> 
> Ada:
> type Parameter is tagged private;
> type Parameter_Access is access Parameter'Class;
> 
> function Allocate(Size: Storage_Unit) return Parameter_Access;
> pragma Import(C, Allocate);
> 
> function Add_To_Lua(Param: in Parameter) return Parameter_Access
> is
> 	Param_Ptr: Parameter_Access;
> begin
>         Param_Ptr:=Allocate(Parameter'Max_Size_In_Storage_Units);
>         Param_Ptr.all:=Param; --[1]
>         return Param_Ptr;
> end;
> 
> Will this do what I want and is is comapritively safe. In particular
> will statement [1] sort of the tag of Param properly? Are there any
> other potential problems.

You might be able to make the above scheme work for *some* types, but it
has some problems.  Parameter'Max_Size_In_Storage_Units returns the
maximum size for all objects of type Parameter (not Parameter'Class).
What you want is the size of Param itself.
Parameter'Max_Size_In_Storage_Units could be (way) too big if the type
has discriminant dependent arrays.  And
Parameter'Max_Size_In_Storage_Units will be too small if Param'Tag /=
Parameter'Tag (i.e. the caller passed in an object from deeper in the
type hierarchy).

What you want is Param'Size (but that's in bits).

It won't work for limited types (because you have an assignment).

There's no way to create an uninitialized heap object.

The storage pool scheme solves all of these problems.
You just do a normal Ada "new", with or without initialization,
as you wish, perhaps with discriminant constraint and whatever
other bells and whistles Ada allows.  The compiler will translate the
"new" into two steps: a call on your Allocate (which calls Lua),
followed by all the Ada-specific default or explicit initializations.

- Bob