Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!qt.cs.utexas.edu!yale.edu!cmcl2!beta!cochiti.lanl.gov!jlg
From: jlg@cochiti.lanl.gov (Jim Giles)
Newsgroups: comp.lang.fortran
Subject: Re: NAG Fortran 90 announcement
Message-ID: <26631@beta.gov>
Date: 27 Jun 91 22:54:34 GMT
References: <1991Jun25.214710.21152@murdoch.acc.Virginia.EDU> <26487@beta.gov> <1991Jun26.173409.443@weyrich.UUCP> <1991Jun27.180712.7293@murdoch.acc.Virginia.EDU>
Sender: news@beta.gov
Organization: Los Alamos National Laboratory
Lines: 46

In article <1991Jun27.180712.7293@murdoch.acc.Virginia.EDU>, gsh7w@astsun8.astro.Virginia.EDU (Greg Hennessy) writes:
|> [...]
|> I am saying that from your discription the Fortran Journal did not
|> consider vectorizing C compilers, so there are no facts to support you
|> guess that there would be an "enormous slowdown" in code translated
|> into C rather than compiled directly by a fortran compiler.

The following codes (Fortran and C):

      subroutine copyit(a,b,n)              void copyit(a,b,n)
      integer n                             int n;
      real a(n), b(n)                       float *a, *b;
      integer i, p, q                       {
                                               float *z; int p, q;
      p = irtc()                               p = _rtc();
      do i=1,n
         a(i) = b(i)                           for(z=a; z<a+n; *z++ = *b++);
      enddo
   1  a(1) = a(n)                              a[0] = a[n-1];
      q = irtc()                               q = _rtc();
      print *, q-p                             printf("%d\n",q-p);
      end                                   }

Both do the same thing.  (CFT77 acepts the Fortran 90 do-loop
syntax.)  The line labeled 1 is there to force the last vector
full of the move to complete before the timing is taken.  Irtc()
and _rtc() are the real time clock intrinsics on Crays for Fortran
and C respectively.

For n=10, the Fortran routine is 5 times as fast as the C version.
For n=10000, the Fortran version is 1.46 times as fast as the C
version.  

I was puzzled by how fast the C version was able to run.  It turns 
out that the new standard C compiler generates two copies of every 
loop and does a run-time check for aliasing in the loop prolog.  
If there is no aliasing, the vector version of the loop is taken, 
otherwise the scalar version is taken.  So, at least for this simple
test case, C did not lose vectorization.  Still a factor of 5 for
small moves is pretty important.  So is a slowdown of 46% for big
moves.

If anyone has a benchmark for a real production code on the Cray
using f2c, I'd like to see it.

J. Giles