Re: GNAT compiler switches and optimization

[claude.simon@equipement.gouv.fr]

with some change you could speedup your code :

First the matrix product is not optimum, you can transpose B.

Second, matrix A is used  vector by vector you can copy A (I,1..N) in a
vector, say AI and replace A(I,R) by AI(R) in the product (it is to the
compiler to see that :-( ).

By apply this change I got an ada version faster that the fortran one
(at the same -O3 optimization level).

You can make the same change to your fortran code and then search a new
trick to speedup your ada code :-).

Claude SIMON

tkrauss a écrit :

> I'm a bit stuck trying to figure out how to coax more performance
> out of some Ada code.  I suspect there is something simple (like
> compiler switches) but I'm missing it.  As an example I'm using
> a simple matrix multiply and comparing it to similar code in
> Fortran.  Unfortunately the Ada code takes 3-4 times as long.
>
> I'm using GNAT (GPL 2006) and GFortran (4.2.0) and the following
> compile options:
>
> gnat make -O3 -gnatp tst_array
> gfortran -O3 tst_array.f95
>
> Running them on 800x800 matrices (on my 2GHz laptop)
>
> for Ada: "tst_array 800" runs in 18 seconds
> for Fortran "tst_array 800" runs in 6 seconds
>
> (if I use the fortran "matmul" intrinsic the fortran time drops to
> 2.5 seconds)
>
> Note, I tried reordering the loops, removing the random calls, etc.
> none of which made huge changes.  There is something killing
> performance
> and/or a switch or two that I'm missing, but I can't seem to find it.
> Any
> thoughts?
>
>
> Here is the code:
>
>
> -- tst_array.adb
> with Ada.Numerics.Float_Random;      use Ada.Numerics.Float_Random;
> with Ada.Command_Line;               use Ada.Command_Line;
> with Ada.Text_IO;                    use Ada.Text_IO;
> with Ada.Calendar;                   use Ada.Calendar;
>
> procedure tst_array is
>    package F_IO is new Ada.Text_IO.Float_IO(Float);
>    package D_IO is new Ada.Text_Io.Fixed_Io(Duration);
>    type Real_Matrix is array(Integer range <>,Integer range <>) of
> Float;
>    type Matrix_Access is access Real_Matrix;
>
>    N    : Positive;
>    G    : Ada.Numerics.Float_Random.Generator;
>
>    A,B,C    : Matrix_Access;
>    Start, Finish : Ada.Calendar.Time;
>    Sum : Float := 0.0;
> begin
>    N := Positive'Value (Argument (1));
>    Start := Ada.Calendar.Clock;
>
>    A := new Real_Matrix(1..N, 1..N);
>    B := new Real_Matrix(1..N, 1..N);
>    C := new Real_Matrix(1..N, 1..N);
>    for I in A'range(1) loop
>       for J in A'range(2) loop
>          A(I,J) := Ada.Numerics.Float_Random.Random(G);
>          B(I,J) := Ada.Numerics.Float_Random.Random(G);
>       end loop;
>    end loop;
>
>    for I in A'range(1) loop
>       for J in A'range(2) loop
>          Sum := 0.0;
>          for R in A'range(2) loop
>             Sum := Sum + A(I,R)*B(R,J);
>          end loop;
>          C(I,J) := Sum;
>       end loop;
>    end loop;
>
>    Finish := Ada.Calendar.Clock;
>
>    F_IO.Put (C(1,1)); F_IO.Put (C(1,2)); New_Line;
>    F_IO.Put (C(2,1)); F_IO.Put (C(2,2)); New_Line;
>
>    Finish := Ada.Calendar.Clock;
>    Put ("Time: "); D_IO.Put(Finish-Start); New_Line;New_Line;
> end tst_array;
>
>
>
> -- tst_array.f95
> program test_array
>    integer,parameter :: seed = 86456
>    integer :: N
>    integer :: numArgs
>    real, dimension(:,:), allocatable :: a, b, c
>    real, dimension(:,:), allocatable :: d, e, f
>    real :: sum
>    character*100 buffer
>    real :: begin, finish
>    integer :: I, J, R
>
>    call getarg(1,buffer)
>    read(buffer,*) N
>
>    call srand(seed)
>
>    begin = second()
>
>    allocate( a(N,N) )
>    allocate( b(N,N) )
>    allocate( c(N,N) )
>    forall (I = 1:N, J = 1:N)
>       a(i,j) = rand()
>       b(i,j) = rand()
>    end forall
>
>    !c = matmul(a, b)
>    do I = 1,N
>       do J = 1,N
>          sum = 0.0
>          do R = 1,N
>             sum = sum + A(I,R)*B(R,J)
>          end do
>          C(I,J) = sum
>       end do
>    end do
>
>    print *, c(1,1), c(1,2), c(2,1), c(2,2)
>    finish = second()
>    print *, 'Time: ', (finish-begin)
>    
> end program test_array