Andy
This is interesting.
I appreciated that you were just supplying representative code. However if
it is possible to avoid dynamic allocation, then you generally get better
performance. Of course, if you want the convenience, it comes at a price at
run time (as with most things in life!).
I too have done some other comparisons using other compilers since my last
post, and it seems that the Compaq compiler is not doing a good job here,
but the Intel 7.0 one is. Why don't you try that one. I believe that you
can get a 30 day free trial download from Intel. If that does the business,
then perhaps that is the solution to your problem.
I am off to bed soon (it is getting on midnight here in England), so don't
look for a further post from me before 16:00 CST Tuesday at the earliest ;-)
Alistair
-----Original Message-----
From: Fortran 90 List [mailto:[log in to unmask]] On Behalf Of
Andy Leonard
Sent: 27 January 2003 22:52
To: [log in to unmask]
Subject: Re: Performance penalties for allocatable arrays?
Alistair,
I actually want the arrays to be of arbitrary size. In my example, they are
allocated to the same size as in the static example just to compare the CPU
times. (Remeber that this is a very trivial example to demonstrate what I
think is the problem with our increased CPU time.)
What we have done in the past is to allocate arrays to be as big as we think
is necessary for all users. Then user X asks to increase the size of array
A. Later user Y asks to increase the size of array B, and so forth and so
on. We can't compile a separate executable for each user. What we want to
do is let each user's model determine the size of all the arrays.
Therefore, we want allocatable arrays.
I have been doing some more profiling on different platforms since my first
post. I used better compiler setting for the XL Fortran compiler. Here are
the relative CPU times when using allocatable arrays and pointers,
repectively, compared to static arrays in a common block.
XL Fortran for AIX 1.02, 1.04
HP F90 v2.6 1.01, 6.30
Sun WorkShop Fortran 95 6.2 0.93, 1.08
Compaq Visual Fortran 6.6A 1.33, 2.24
The results vary quite a bit on different platforms. I can take the 2% on
the Unix machines, but the PC is the platform I need to be most concerned
with.
Andy
At 04:14 PM 1/27/2003, you wrote:
>Andy
>
>The reason for the big difference in performance, is that your two
>programs are quite different!
>
>In prog2, you use static allocation at compile time, and so the
>computer does not have to check any aspect of the allocation at run
>time.
>
>In prog1, you allocate something of arbitrary size and then call a
>routine 1000 times. Each time the routine must determine if there is
>anything allocated, and if there is how big it is and where it is, and
>take appropriate action if conditions are not good.
>
>Try the following program which I think is similar to your common
>example and uses the static idiom with the module. The performance is
>the same as with your common block example. (well it is on my Compaq
>Visual Fortran compiler on PC).
>
>Hope that this helps.
>
>Alistair
>
>PS I have made small changes to prog1.f90 and prog2.f90 to make them
>more to my taste, and so I attach those also.
>
>Prog3.f90
>
>!==============================
> module A_MOD
> implicit none
>
> private
> integer, parameter, public :: na = 1024*96
> real, public :: dt = 1.0/1024
> real, dimension(na), public :: A, dAdt
>
> end module A_MOD
>!==============================
> program main
>
> use A_MOD, only: na, A, dAdt, dt
> implicit none
> integer :: i, n
>
> dt = 1.0/1024
> A(:) = 0
> dAdt(:) = 1
>
> do i = 1, 10
> do n = 1, 1024
> call SUB
> enddo
> print *, a(n)
> end do
>
> end
>!==============================
> subroutine SUB
>
> use A_MOD, only: na, A, dAdt, dt
> implicit none
> integer :: n
>
> do n = 1, na
> A(n) = A(n) + dAdt(n)*dt
> enddo
>
> end
|
