Hi,

I was wondering whether global array operations, introduced in f90,
can have a negative impact on performance. Compare:

do i=1, ntheta
r(0,i) = rhub
r(nr+1,i) = rmax
dt(0,i) = 0.0
dft(0,i) = 0.0
dfr(0,i) = 0.0
dt(nr+1,i) = 0.0
dft(nr+1,i) = 0.0
dfr(nr+1,i) = 0.0
end do

with:

On 17 Jun., 17:41, deltaquattro gmail.com> wrote:

This is quite a strange observation and raises some questions:

1) What optimisation options did you use?

"deltaquattro" gmail.com> wrote in message
news:9c706700-2861-4d17-a3b8-7e2291fa0b5f@2g2000hsn.googlegroups.com...

deltaquattro gmail.com> wrote:

[elided initialization with DO loops and whole array operations]

Note that the usual terminology is something more like "whole array
operations" or even just an unmodified "array operations" instead of
"global".

The main reasons are clarity and conciseness. If it doesn't help clarity
and conciseness, don't do it. That is, no doubt, an oversimplification;
there are exceptions, etc. But its a good first approximation. Every
once in a while they might also get you faster execution, but if that is
your primary reason for using them, and you don't have specific
knowledge of exactly why to expect faster execution from your paticular
case, then your efforts are probably misplaced.

On 17 Jun., 20:31, nos...@see.signature (Richard Maine) wrote:

Beats me.
After all, when using array operations you have additional information
either readily available, or you are able to extract it fairly easy,
which is not always the case in DO loops. Talk about aliasing,
strides, contingent memory locations etc. But then again, "See point
1".
I actually find this hard to believe, but given that I'm rather new to
the delightful post-77 Fortran world and haven't really done any
serious benchmarking on array operations vs DO loops, I'll gladly
trust your judgement on this. Thanks for enlightening us!

In article <9e1269be-de8c-4971-857d-e95bf639d7d8@i76g2000hsf.googlegroups.com>,
Dennis Wassel googlemail.com> writes:

On 17 Jun., 22:41, ka...@troutmask.apl.washington.edu (Steven G.
Kargl) wrote:

This sounds dangerously like "don't do this, unless you *really* want
to".
Right'o, gimme something to fill my umpteen MBs of terminal buffer :)

James Van Buskirk wrote:
(snip of example with DO loops)

Dennis Wassel wrote:
(snip, and previously snipped DO vs. array expressions)

To make a fair comparison, it should be separate DO loops
vs. array operations, and separate DO loops vs.
a single DO loop. Then you can separate the difference
due to memory access patterns and actual instructions.

My usual rule is that simple array operations are better than
(or at least as good as) DO loops, but more complicated ones
are slower. (Especially if temporary arrays are used.)

-- glen

glen herrmannsfeldt wrote:

I suspect, given the context, that outside of this initialization, the
subscripts are accessed in the correct order.