Subject: Parkbench Minutes

From: [email-masked]
Date: Wed, 1 Sep 93 11:06:27 GMT

Although not present, I have the following comments on the minutes:

>correct assessment might be "20 flop".  Phil T. pointed out that the Cray HPM
>was used for flop counts of the Perfect Benchmarks.  Bodo P. asserted that
>since caching is typically used to evaluate many
>intrinsic functions, reported counts might be distorted.  Tony H. stressed that

                    POINT NEEDING CLARIFICATION
                    ---------------------------
    An intrinsic function is evaluated from a series or other formula
    with a fixed and known number of mults and adds. I do not understand
    how this number is changed if caching is used or not. I do agree
    that the number of memory references and the time of execution will 
    change, but these are not the points at issue. The number of flop is 
    always the same.

>data-access rate, for example.  David B. agreed to modify Section 2.4 to
>include a memory parameter, and then asked whose responsibility is it to 
>produce 
>flop counts for the Parkbench codes?  He suggested that a formula be given for

                        MY OPINION EXPRESSED LATER
                        --------------------------
     I (rwh) suggest that the responsibility for deciding on the official
     flop-count be that of the benchmark writer, because in complex codes
     he is probably the only one who knows what is going on well enough
     to dream-up a formula that is accurate enough for the purpose but
     not too complex to use easily. It is often a matter of judgement
     what approximations to make or what terms to omit.

>suggested that the first sentence in the Introduction (Chapter 1) indicate that
>"scalable distributed-memory (message-passing)" be the target architectures.
>The role of shared-memory architectures was not clear to several attendees.

                      NOTE FROM THE ABSENT CHAIRMAN
                      -----------------------------
     I (rwh) think that to specify scalable distributed-memory (message-
     passing) as the target architecture is unnecessarilly restrictive
     because our F90 and HPF versions are intended for use on other
     architectures (e.g. non-MP SIMD, and shared memory). That is why
     the report is entitled generally as "Benchmarks for Parallel Computers",
     not "Benchmarks for Message-Passing computers". Also the word
     scalable is bad: all parallel computers (both shared memory and 
     distributed) are scalable up to some practical limit, the correct 
     question is not whether they scale or not, but is by how much 
     do they scale. 

>particular code was not readily available.  Ed K. suggested that feedback fro
>the Scientific Community was agreed.   Tony H. concurred.  Joanne M. suggested
               Meaning of middle sentence unclear?
               
                 NOTE THE FOLLOWING MINOR TYPOS
                 ------------------------------
>	        TICK1, TICK2, RIF1, POLY1, POLY2 (Roger H.)
should be:	TICK1, TICK2, RINF1, POLY1, POLY2 (Roger H.)
correction:                     *

>	        COMMS1, COMMS2, COMMS3, POLY3, SYNC1 (Roger H.; need PVM versions)
should be:	COMMS1, COMMS2, COMMS3, POLY3, SYNCH1 (Roger H.; need PVM versions)
correction:                                        *

                        Roger Hockney

---

From: [email-masked] (Bodo Parady - SMCC Systems Performance)
Date: Wed, 1 Sep 1993 14:04:36 +0800

> From [email-masked] Wed Sep  1 13:40 PDT 1993
> X-Resent-To: [email-masked] ; Wed, 1 Sep 1993 07:14:10 EDT
> From: [email-masked]
> Date: Wed, 1 Sep 93 11:06:27 GMT
> To: [email-masked]
> Subject: Parkbench Minutes
> 

There are two ways of calculating intrinsic functions:

	a = F(x)

Where f is a function of multiplies and adds, and

	a = Table(x ;x)
                   i

when x=x  in the table, the value is calculated by table lookup.  For 
	i

example, take the Fortran loop:

	do 1000 i = 1, m
		do 2000 j = 1, n
			A(i, j) = B(i,j) * sin (i*j*PI/20)
2000		continue
1000	continue

For a no-caching intrinsic function (sine/cosine), n*m*(number of ops to
do sine) would be performed.  For a caching intrinsic, the ops count
could be approximately (40*(number of ops to do sine) + n*m (modulos + loads)).

Any benchmark that includes intrinsics could try to assure that the intrinsic
is never called with the same or similar (the sine example above) value,
making this concern moot.

>...> 
								Bodo