PRACE NPT

*************************************************

* Program:  STREAM2                             *

* Revision: 0.1, 99.10.26                       *

* Author:   John McCalpin                       *

*           john@mccalpin.com                   *

*************************************************

*-----------------------------------------------------------------------

* Copyright 1991-2003: John D. McCalpin

*-----------------------------------------------------------------------

* License:

*  1. You are free to use this program and/or to redistribute

*     this program.

*  2. You are free to modify this program for your own use,

*     including commercial use, subject to the publication

*     restrictions in item 3.

*  3. You are free to publish results obtained from running this

*     program, or from works that you derive from this program,

*     with the following limitations:

*     3a. In order to be referred to as "STREAM2 benchmark results",

*         published results must be in conformance to the STREAM

*         Run Rules, (briefly reviewed below) published at

*         http://www.cs.virginia.edu/stream/ref.html

*         and incorporated herein by reference.

*         As the copyright holder, John McCalpin retains the

*         right to determine conformity with the Run Rules.

*     3b. Results based on modified source code or on runs not in

*         accordance with the STREAM Run Rules must be clearly

*         labelled whenever they are published.  Examples of

*         proper labelling include:

*         "tuned STREAM2 benchmark results"

*         "based on a variant of the STREAM2 benchmark code"

*         Other comparable, clear and reasonable labelling is

*         acceptable.

*     3c. Submission of results to the STREAM benchmark web site

*         is encouraged, but not required.

*  4. Use of this program or creation of derived works based on this

*     program constitutes acceptance of these licensing restrictions.

*  5. Absolutely no warranty is expressed or implied.

*-----------------------------------------------------------------------

*************************************************

* This program measures sustained bandwidth     *

* using four computational kernels:             *

*                                               *

*       FILL:   a(i) = 0                        *

*       COPY:   a(i) = b(i)                     *

*       DAXPY:  a(i) = a(i) + q*b(i)            *

*       DOT:    sum += a(i) * b(i)              *

*                                               *

* Results are presented in MB/s, assuming       *

*   8 Bytes per iteration for FILL and SUM,     *

*  16 Bytes per iteration for COPY, and         *

*  24 Bytes per iteration for DAXPY             *

*************************************************

	program stream2_mpi

	IMPLICIT NONE

        include 'mpif.h'

        integer numtask, rank

        integer rc, mpierr

        DOUBLE PRECISION rc1

	integer NMIN, NMAX, NTIMES, NUMSIZES

	parameter (NMIN=30,NMAX=2 000 000)

	parameter (NTIMES=10,NUMSIZES=32)

	integer NPAD

	parameter (NPAD=5)

	real*8 a(NMAX+NPAD),b(NMAX+NPAD)

	real*8 time(4,NTIMES),mysecond,scalar,inner

	real*8 sum,start,finish

	real*8 rate(4),besttime(4),bytes(4),rsum(4)

	real*8 exp,tdelta

	logical ALLTIMES

	integer i,j,k,l,M

	external mysecond

	data bytes/8,16,24,8/

	data ALLTIMES/.false./

*     .. MPI Initialization ..

      call MPI_INIT ( rc )

      if ( rc .ne. 0 ) then

         WRITE(*,*) ' MPI Initialization problem, error code: ',rc

         stop

      endif

      call MPI_COMM_RANK ( MPI_COMM_WORLD, rank, rc )

      call MPI_COMM_SIZE ( MPI_COMM_WORLD, numtask, rc )

	if ( rank .eq. 0 ) then

* check timer granularity

	do i=1,min(10000,NMAX)

	    a(i) = 0.0d0

	end do

	do i=1,min(10000,NMAX)

	    a(i) = mysecond()

	end do

	tdelta = 1.d36

	do i=1,min(10000,NMAX)-1

	    if (a(i+1).ne.a(i)) then

		tdelta = min(tdelta,abs(a(i+1)-a(i)))

	    end if

	end do

	print *,'Smallest time delta is ',tdelta

	print *,'    Size  Iter     FILL      COPY     DAXPY       SUM'

	endif

* Loop over problem size

	do j=1,NUMSIZES

	    exp = log10(dble(NMIN)) + dble(j-1)/dble(NUMSIZES-1)*

     $          (log10(dble(NMAX))-log10(dble(NMIN)))

	    M = NINT(10.**exp)

* Initialize Arrays

	    do i=1,M

	        a(i) = 0.0d0

	        b(i) = 0.0d0

	    end do

	    do k=1,NTIMES

		inner = NMAX/M

            call MPI_BARRIER( MPI_COMM_WORLD, rc)

	        start = mysecond()

		do l=1,inner

	            scalar = dble(k+l)

	            do i=1,M

	    	        a(i) = scalar

	            end do

	        end do

	        finish = mysecond()

	        time(1,k) = (finish-start)/dble(inner)

            call MPI_BARRIER( MPI_COMM_WORLD, rc)

	        start = mysecond()

		do l=1,inner

                    a(l) = 1.0d0

	            do i=1,M

		        b(i) = a(i)

	            end do

	        end do

	        finish = mysecond()

	        time(2,k) = (finish-start)/dble(inner)

            call MPI_BARRIER( MPI_COMM_WORLD, rc)

	        start = mysecond()

		do l=1,inner

                    a(l) = 1.0d0

	            do i=1,M

		        b(i) = b(i) + scalar*a(i)

	            end do

	        end do

	        finish = mysecond()

	        time(3,k) = (finish-start)/dble(inner)

            call MPI_BARRIER( MPI_COMM_WORLD, rc)

	        start = mysecond()

		do l=1,inner

                    b(l) = 1.0d0

	            sum = 0.0d0

	            do i=1,M

		        sum = sum + a(i)*b(i)

	            end do

	        end do

	        finish = mysecond()

	        time(4,k) = (finish-start)/dble(inner)

            call MPI_BARRIER( MPI_COMM_WORLD, rc)

	    end do

	    do i=1,4

		besttime(i) = 1.d+36

	        do k=1,NTIMES

	            besttime(i) = min(besttime(i),time(i,k))

		    if (ALLTIMES) print *,i,k,time(i,k)

	        end do

	        rate(i) = dble(M)* bytes(i)/besttime(i) / 1.d6

	    end do

	    call MPI_REDUCE(rate, rsum,4, MPI_REAL8, MPI_SUM, 0

     $ , MPI_COMM_WORLD, mpierr)

	    if ( rank .eq. 0 ) then

	    write (*,1) M,NTIMES,rsum(1)/numtask,rsum(2)/numtask,

     $ rsum(3)/numtask,rsum(4)/numtask, tdelta/besttime(1)

	    open (unit=3,form='unformatted')

	    write (3) sum

	    close (unit=3)

	    endif

	end do

    1	format (1x,i8,2x,i4,1x,5(f8.1,2x))

        call MPI_FINALIZE ( rc )

	end