Re: 10 rules for benchmarking (was Re: Teaching new tricks to an old dog (C++ -->Ada))

[Georg Bauhaus <sb463ba@user1.uni-duisburg.de>]

CTips wrote:

  [a C program for measureing p[i] in Ada]

Ada program below. It isn't really much longer than the C program
as some seem to have expected.

> This is not intended to be a real program; it is meant to illustrate how 
> much slower Ada can get than C. Try and write it as specified and 
> measure the resulting performance.

Done. Performance: either a 10%--50% slowdown, or exactly the
same speed.

The  "Ada" program below has values for N and N2 so that I am at least
seing some repeatable figures, but I have tried other values as well.
(The L2 processor cache is 256k bytes in size). The C program used
for comparison has the exact same values.

As you suggested, I have not tried to write an Ada program really,
but instead to write the same program using Ada for writing C.
The result is twofold:

1) The execution speed of Ada is either much less, 0.92 vs 1.36, or
2) The execution speed is the same, 0.92 vs 0.92.

For reasons of explanation, (2) is achieved when you remove a
null pointer check that Ada requires for pointer p when doing
pointer arithmentic, that is when computing p[1]. The pointer
arithmetic function "+" from  Interfaces.C.Pointers has been
modified so that it omits the null test. But
DON'T DO THIS when writing Ada programs, you are messing
with Ada's meaning! Ada programs don't do arithmetic on null
pointers!)

    function "+" (Left : Pointer; Right : ptrdiff_t) return Pointer is
    begin
--C     if Left = null then
--C         raise Pointer_Error;
--C      end if;

       return To_Pointer (To_Addr (Left) + To_Addr (Elmt_Size * Right));
    end "+";

With this change the "Ada" program is exactly as fast as the C
program. I hear the opportunist say that you have to modify the
Ada library in order to get fast programs... Oh well, so much
for rationality in language comparisons ...


gcc -O2 -ansi -pedantic (C)
gnatmake -O2 -gnatp -gnatN (Ada)

GCC 4.0.0 20050215, 2xPIII 800MHz 256k, 1G, load low, no jobs.
$ while true ; do ./a.out ; done     # done many times


with Perm_Arrays;

procedure c is
    use Perm_Arrays;

    p, q: Int_Array(0 .. N);
    x: Ptr_Array(0 .. N2);

begin
    setup_array(x, p, q);
    for i in 1 .. 30_000 loop
       do_array(x);
    end loop;
end c;

with Interfaces.C.Pointers;

package Perm_Arrays is
    use Interfaces;

    N: constant := 3000;
    N2: constant := 6000;

    type Int_Array is array (Natural range <>) of aliased Integer;
    type Int_Ptr is access all Integer;

    package Int_Arrays is
      new C.Pointers(Natural, Integer, Int_Array, -1);

    type Ptr_Array is array (Natural range <>) of Int_Arrays.Pointer;

    procedure do_array(x: in Ptr_Array);
    procedure setup_array(x: out Ptr_Array; p, q: in out Int_Array);

end Perm_Arrays;


package body Perm_Arrays is

    use Int_Arrays;

    procedure do_array(x: in Ptr_Array) is
       p: Pointer;
    begin
       for i in x'range loop
          p := x(i);
          increment(p);
          p.all := i;
       end loop;
    end do_array;

    procedure setup_array(x: out Ptr_Array; p, q: in out Int_Array) is
    begin
       for i in p'range loop
          x(i) := p(i)'unchecked_access;
          x(i + N) := q(i)'unchecked_access;
       end loop;
    end setup_array;

end Perm_Arrays;


--  Georg