Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10.2 9/18/84; site dartvax.UUCP
Path: utzoo!watmath!clyde!burl!ulysses!ucbvax!decvax!dartvax!chuck
From: chuck@dartvax.UUCP (Chuck Simmons)
Newsgroups: net.arch
Subject: Re: RISC and MIPS
Message-ID: <3517@dartvax.UUCP>
Date: Fri, 23-Aug-85 06:44:18 EDT
Article-I.D.: dartvax.3517
Posted: Fri Aug 23 06:44:18 1985
Date-Received: Sun, 25-Aug-85 00:48:21 EDT
References: <419@kontron.UUCP> <2300001@uicsl> <1093@ames.UUCP>
Organization: Dartmouth College, Hanover, NH
Lines: 41

> A problem is, certainly, how we measure things.  One letter brought out
> the need to define what an instruction was.  The letter did not specifically
> mention a property by name: that was `atomicity.'  ...
> Whetstones were mentioned in another letter, but the only people
> who use these are computer manufacturers.  [MGT]FLOPS are another gastly
> measure.  What qualities do our performance metrics need to have?
> 
> --eugene miya

It might be interesting to define some fairly simple standard operations
and ask how long it takes to perform the operations.  Typical standard
operations might be:   (high-level language pseudo-code in parens)

add -- takes two words (at least 32 bits) from memory, adds them together,
and puts the result back in memory.  (A := B + C)

index -- picks up an array offset from memory, performs bounds checking
on the offset (we don't all write in C), and loads the indexed element into a
register.  (A[i])

ptr_load -- picks up a pointer and an offset into a record and loads
the appropriate word from the pointed to record.  (P->Record.Field)

array_loop -- load each element of an array into a register.  It is
cheating to assume that the array contains a special value at either
end.  (for i = 1 to n do ... A[i] ...;)

The advantage of using these simple operations instead of FLOPS is that
a lot of programs don't use floating point operations very much.  These
simple operations would be a better measure than even simpler instructions
because each operation does something "useful".  These operations can
also have advantages over high-level language benchmarks because they are
not dependent on the quality of a compiler.

The qualities that I am aiming for here are primarily usefulness and 
simplicity.  Each of the above operations will be found in a wide variety
of programs, and each operation should be easy to implement on most
machines in that machines native assembler.  These are short pieces of
code that a compiler would generate fairly often.

-- Chuck
chuck@dartvax