Re: copying data between memory locations

[Niklas Holsti <niklas.holsti@nospam.please>]

jef.mangelschots@gmail.com wrote:
> In our current design, we have a package that maintains a list of
> descriptors of various buffers in the application. We don't want to
> know their datatypes or how to write data into them. We only want to
> maintain a physical address of them and use that address to directly
> write data into these buffers (this data comes out incoming packets
> over the network).
> 
> In C, this is very straightforward and use the address as a pointer
> and simply copy the packet into the memory location.

Easy to code, hard to debug, ... as you probably know :-)

> I can't figure out a way to do this in Ada (at least not Ada83).
> 
> suppose the following:
> 
> type BUFFER_DETAILS_RECORD is
> record
>     num_bytes : integer;
>     start_address : system.address;
> end record;
> type BUFFER_DETAILS_ARRAY_TYPE is array(1..2) of
> BUFFER_DETAILS_RECORD;
> BUFFER_DETAILS : constant BUFFER_DETAILS_ARRAY_TYPE :=
> BUFFER_DETAILS_ARRAY_TYPE'(1 => (num_bytes => 100, start_address =>
> 16#123# ),  1 => (num_bytes => 200, start_address => 16#456# ));
> 
> procedure insert_block(idx : in integer; num_bytes : in integer;
> offset : in integer; data : BYTE_ARRAY_TYPE) is
> begin
>    ??? how do I copy the content of data into the memory pointed to by
> BUFFER_DETAILS(idx).start_address + offset
> end;

You have two problems, in fact: (1) adding an address and an 
(integer) offset to give a new address, and (2) accessing the data 
at that address.

For the addition problem (1) Ada 95/2007 provide the standard 
package System.Storage_Elements. For Ada 83 I don't know of any 
standard method; I would look for a compiler-specific method, 
perhaps compiler-specific functions in package System or in some 
other compiler-supplied package. You could also try to use 
Unchecked_Conversion to convert System.Address to some integer 
type, add the integers, and convert back, but that works only if 
the System.Address is really implemented as an integral type (and 
not, for example, as a segment + offset). But you can also delegate 
the offset to the second problem (2), see below.

For the accessing problem (2) Ada 95/2007 provide the standard 
package System.Address_To_Access_Conversions that can be used to 
convert the physical address into an access to the buffer, of any 
type desired, for example a Byte_Array_Type.

In Ada 83 there are two methods for accessing data at a given 
System.Address:

- Declare an "overlay" for the buffer using an address clause:

      Vec : Byte_Array_Type;
      for Vec use at the_known_address;

   The LRM says that this feature "should not" be used to achieve
   overlays of objects. In practice it is (or was) used in this
   way, at least when the compiler supported it.

- Use Unchecked_Conversion to convert the physical address to
   an access value (access Byte_Array_Type). This works only if
   access values are really implemented as addresses, which is not
   always the case.

If you always access the buffer as a vector of bytes, you could 
delegate problem (1) to problem (2) by setting up the overlay or 
the access value using Buffer.start_address without including the 
offset, then adding the offset part when you index the Byte_Array, 
using Vec(Buffer.offset), Vec(Buffer.offset+1) .. instead of 
Vec(0), Vec(1), ...

HTH

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .