Re: Surprise in array concatenation

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On 05 Sep 2005 18:13:16 -0400, Robert A Duff wrote:

> But the Ada rule is _certainly_ not the "most efficient"!
> 
> If all Strings start at 1, then we reduce the size of the array dope by
> 4 bytes.  If the average String length in your program is, say, 20
> bytes, you're saving 4 bytes for every 24, or about 17% of the memory
> use, which is substantial.  Saving memory generally speed up programs
> due to cache effects.
>
> It's really annoying to me that the compiler stores zillions of copies
> of the number 1 in memory (one copy for each String object), just
> because some oddball String _might_ start at other than 1.
> 
> Furthermore, bounds checking would be much faster, because there would
> be no need to load the lower-bound from memory.  Memory loads are often
> slow on modern machines.
> 
> Furthermore, consider the code generated for 'Length:  In Ada, it's
> something like:
> 
>     if X'First <= X'Last then
>         X'Last - X'First + 1
>     else
>         0
>     end if;
> 
> If X'First were known to be always 1, it would be:
> 
>     X'Last
> 
> If X'First were known to be always 17, it would be:
> 
>     X'Last - 16
> 
> These latter are branch-free code sequences.  Branches are often slow on
> modern machines.

Right. Here is another example to the list: almost any binary operation on
strings should do:

J := B'First;
for I in A'Range loop
   do something to A(I) with B(J);
   J := J + 1; -- Can this overflow at the end of loop? (:-))
end loop;

or its equivalent. It would be much less pain if either A'First = B'First
(for some arrays, as a part of the contract), or at least array renaming
worked properly (could shift the bounds.)

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de