Does fortran 90 (gfortran) optimise array syntax?

Question

I have done a lot of work with array-based interpreted languages, but I'm having a look at Fortran. What has just occurred to me after writing my first bit of code is the question of whether or not gfortran will optimise an expression using array syntax by placing the expression in a single loop. In most array-based interpreters an expression such as A=B/n*2*pi (where B is an array) would require 5 loops and multiple array temporaries to evaluate. Is gfortran clever enough to optimise this out, and will my code below (the line that calculates the array from 0 to 2pi) be as efficient as an explicit do loop around the expression? Is there anything I should look out for when using array syntax if I'm worried about performance?

PROGRAM  Sine
   IMPLICIT  NONE

   REAL, PARAMETER :: PI = 3.415926535
   INTEGER, PARAMETER :: z = 500
   INTEGER :: ier
   INTEGER, EXTERNAL :: PGBEG
   REAL, DIMENSION(z) :: x,y

   x=(indgen(z)-1.0)/z*(2*pi) ! This line...``
   y=sin(x)
   CALL plot(y,x)

   CONTAINS

     FUNCTION indgen(n) result(i)
       INTEGER :: n
       INTEGER, DIMENSION(n) :: i
       INTEGER :: l
       DO l=1,n
          i(l)=l
       END DO
     END FUNCTION indgen

    SUBROUTINE plot(y,x)
       REAL, DIMENSION(:) :: x,y
       ier=PGBEG(0,'/XWINDOW',1,1)
       CALL PGENV(0.0,7.0,-1.0,1.0,0,1)
       CALL PGLINE(SIZE(x),x,y)
       CALL PGEND()
     END SUBROUTINE plot

END PROGRAM Sine

Xiaolei Zhu · Accepted Answer · 2013-11-30 17:44:34Z

2

In gfortran you can use the -Warray-temporaries flag to see all array temporaries generated. When I try your example no extra array temporary is generated (other than the one necessary to store the results of indgen(z)), so I guess gfortran is clever enough.

edited Nov 30, 2013 at 17:44

answered Nov 30, 2013 at 16:51

Xiaolei Zhu

5274 silver badges10 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Sean Patrick Santos · Accepted Answer · 2013-11-30 19:54:48Z

The expression z*(2*pi) is a compile-time constant, which the compiler can easily verify, so that should not be evaluated at run time regardless. Additionally, virtually all modern compilers should perform one-line "elemental" array operations within a single loop, and in many cases SIMD instructions will be generated (auto-vectorization).

Whether a temporary is generated usually depends on whether or not each element can be handled independently, and whether or not the compiler can prove this. Xiaolei Zhu's suggestion of using -Warray-temporaries is a good one. Don't mix this up wih -fcheck=array-temps, which I think only applies to temporaries generated for function calls.

Here's an example of such a message from gfortran:

foo.F90:4.12:

foo(1:20) = 2*foo(20:1:-1)
            1
Warning: Creating array temporary at (1)

Your function call will be done in a separate loop, unless the compiler can inline it. Whether or not the compiler inlines a short function can be pretty unpredictable; it potentially depends on where that other function is defined, whether or not the function has the pure attribute (although in practice this rarely seems to matter), the vendor and version of the compiler itself, and the options you pass. Some compilers can generate a report for this; as I recall, the Intel compiler has a decent one.

Edit: It's also possible to inline the expression in this line pretty easily by hand, using an "implied do loop":

x = [ ( real(i)/z*(2*pi), i = 0, z-1) ]

EvilTeach · Accepted Answer · 2013-11-29 22:55:08Z

0

Yes. Fortran is compiled rather than interpreted. It handles loops very well.

answered Nov 29, 2013 at 22:55

EvilTeach

29k21 gold badges89 silver badges144 bronze badges

1 Comment

David Wallis Over a year ago

Thanks, but that doesn't answer my question. I'm not asking if a compiler handles loops better that an interpreter, I'm trying to figure out if it encloses the expression in a single loop rather than doing each operation in turn like in many interpreted array languages. Thinking about it a bit more, I'm guessing my code is compiled as at least 2 loops; one inside indgen and at one (or more?) to evaluate the rest of the expression.

Collectives™ on Stack Overflow

Does fortran 90 (gfortran) optimise array syntax?

3 Answers 3

Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related