Re: GNAT compiler switches and optimization

[claude.simon@equipement.gouv.fr]

A way to have better performance is to optimize the use of the memory
cache.

An Ada writen matmul procedure to tend to the fortran intrinsic matmul
speed with -O2 and -gnatp


ada     version with array size of 600 : time = 0.6722
fortran version with array size of 600 : time = 0.6094


package Array_Product is

   type Real_Matrix is array(Integer range <>,Integer range <>) of
Float;
   type Matrix_Access is access Real_Matrix;

   procedure Matmul (A, B : in Real_Matrix; C : out Real_Matrix);

end Array_Product;


package body Array_Product is

   procedure Matmul (A, B : in Real_Matrix; C : out Real_Matrix)
   is
      BL : array (1 .. B'Length (1) * B'Length (2)) of Float;
      D  : Natural := 0;
      Sum : Float := 0.0;
   begin
      D := 0;
      -- transposition gave the best speedup cache + only one indice
     Transpose_B_in_BL :
      for J in B'Range (1) loop
         for R in B'Range (2) loop
            BL( D + R) := B(R,J);
         end loop;
         D := D + B'Length (2);
      end loop Transpose_B_in_BL;

      for I in A'Range (1) loop
         declare
            -- give the cache best chance with A second speedup
            Ai : array (A'range (2)) of Float;
         begin
            for R in Ai'Range loop
               Ai (R) := A (I, R);
            end loop;
            D := 0;
            for J in A'range(2) loop
               Sum := 0.0;
               for R in A'Range (2) loop
                  Sum := Sum + Ai(R)*BL(D + R);
               end loop;
               D := D + A'Length (2);
               C(I,J) := Sum;
            end loop;
         end;
      end loop;
   end Matmul;

end Array_Product;






Jeffrey Creem a écrit :

> Jeffrey R. Carter wrote:
> > Jeffrey Creem wrote:
> >
> >>
> >> 2) Small changes to the original code that still meet the original
> >> structure and intent of the original code can move the run time up and
> >> down by at least 50%
> >> 3) The two task based version of the code is running more than 2x
> >> faster than the single task version on a 2 processor machine. Some of
> >> this is from the two tasks but looking at the assembly, another
> >> portion of it is  related to #2 above in that the re-arrangement of
> >> the math allows the compiler to get less brain dead.
> >
> >
> > These seem quite odd to me. Perhaps whatever is causing this is also the
> > cause of the speedup I saw in the sequential case when the
> > multiplication is put in a procedure.
> >
>
> Ok, we are all probably tired of taking about this topic but I posted
> what I think will be the final write-up on this (until the bugzilla
> issue for it is resolved).
>
> http://gnuada.sourceforge.net/pmwiki.php/Main/Oct2006CLAGFORTRANComparison
>
> And I agree that the > 2x speedup for the two task version is not real.
> There are now other versions that are coded in a similar maner to the 2
> task version but which are single threaded. The 2 task version runs
> almost exactly 2x faster (sometimes slightly slower) on my dual
> processor machine.