[net.micro] NS 16032 timing measurements

drg (10/23/82)

We've done some preliminary speed measurements on the NS16032
microprocessor.  The following numbers are the cpu times in seconds
needed to execute 5 million of the indicated operations.

                       VAX          16032          68000
                   780      750      6MHz           6MHz

null loop         14.3     26.7      34.0           30.0
long reg+reg       2.4      6.8       4.5            7.3
short reg+reg      2.4      6.8       4.5            4.0
long reg+const     3.2      6.5      13.0           16.0
short reg+const    4.3      7.2       8.0            8.0
long+const         6.6      9.3      27.5           33.3
short+const        6.8     10.8      17.5           20.0
long*const        12.0     48.3     100            560   * See Note 1
short*const       11.5     32.9      67             62

NOTES:
1) The 68000 and the 16032 seem to be about the same speed, except that
the 16032 has a 32 bit ALU and the 68000 only has a 16 bit one.  Long
arithmetic on the 16032 is faster.  The 68000 does not have a 32 bit
multiply instruction, and the number in the table reflects the time
needed to simulate it.

2) Although it is hard to tell, the VAX 11/750 may actually be slower
than the two micros, but its cache gives it a great advantage on
memory accesses.

3) We don't have any hard numbers, but it appears that the code size for
the 16032 is noticably smaller than that for the 68000.

4) We don't have a 6 MHz 68000.  All we have is a 4 MHz one, and I
took the numbers for it and multiplied them by .66.  You can buy
12 MHz 68000 chips, and National is promising 10 MHz 16032 chips.

5) Neither micro is using a memory management.  Both VAXes do, of course.
We have the memory management chip for the 16032, just haven't used it
yet.

6) The benchmarks should be taken with a grain of salt.  They were
written in a high level language (Concurrent Euclid), rather than
assembler.  They do not test important things like procedure calling,
argument passing, etc.

7) The benchmarks were all written in Concurrent Euclid, and compiled
under 4.1BSD.  The long+const example follows; the others are similar.

var Test: module
include '%IO'

    initially imports (var IO)
        begin
            register var i : SignedInt
            register var j : SignedInt
            var sum : LongInt := 0

            IO.PutString('Test begins$N$E')
            i := 1
            loop
                exit when i >= 500
                j := 1
                loop
                    exit when j >= 10000
                    sum := sum + 45
                    j := j + 1
                end loop
                i := i + 1
            end loop
            IO.PutString('Test complete$N$E')
        end
end module

                -- Dave Galloway, CSRG, University of Toronto