Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!linus!decvax!harpo!seismo!hao!cires!nbires!ut-ngp!utastro!nather
From: nather@utastro.UUCP
Newsgroups: net.arch
Subject: Re: uP architecture and the NOVA
Message-ID: <471@utastro.UUCP>
Date: Thu, 21-Jul-83 00:00:27 EDT
Article-I.D.: utastro.471
Posted: Thu Jul 21 00:00:27 1983
Date-Received: Sat, 16-Jul-83 01:30:24 EDT
References: orca.1358
Lines: 54


	I can't believe that people are holding up the NOVA instruction set as
	a design to be emulated!
	              *          *          *          *
	Addresses refer to 16-bit words, rather than to bytes.  At first glance
	this looks like a trade-off of byte-addressability for a double-sized
	address space, right?  Nope, addresses are *fifteen* bits wide ... the
	high bit of a sixteen bit word is ignored (at east on the original NOVA
	design).

The high bit is not ignored; it is used as an indirection flag so that a
15 bit value in memory can be designated as either a direct address (high
order bit zero) or an indirect address (high order bit 1).  This allows
multiple indirection, which an assembly-language programmer can use to
good advantage, and which a code generator cannot.
	
	Sure, a horizontal instruction set looks elegant, but just try writing
	a code generator when you have a flock of users who want absolutely
	optimal code.  The complexity of the task is exponential with the
	number of independent operations which a single instruction can perform.
	
	Give me an 8080 any day!
	
	  -- Andrew Klossner   (decvax!teklabs!tekecs!andrew)  [UUCP]
	                       (andrew.tektronix@rand-relay)   [ARPA]

Here is the crux of the matter.  A single arithmetic instruction on a
nova consists of five (5) separate, sequential operations: set the
carry (0, 1, ~, or NOP), do the operation (add, subtract, complement, etc),
shift the result (0 or 1 bit position), test the result (value or carry),
then save the result (in a register) or discard it.  It takes a while
to adapt to this sequence, and most programmers find it awkward to
start.  With practice and experience, though, it becomes possible to
write short, compact and efficient code, using very few instructions.
It tastes a lot like C, where a single statement can do several things
at considerable savings in time and clutter.

Designing a code generator is something else entirely.  An experienced
Nova programmer can adapt to this sequence and write fast code, but a
compiler (for any langauge) really can't, and the addressing limitations
compound the problem.  Compiled code is bulky, inefficient and slow.
Example: the "Sieve" program, written in "hand-honed" assembly language,
takes 1.3 sec on a Nova 3.  The same program compiled from Fortran code
(pinched from "Byte") takes 22 times longer on the same machine.

In my opinion, the Nova architecture is a fully-matured example of an
instruction set designed for effective assembly-language programming,
and as such is both elegant and passe.  It is an architecture whose
time has come and gone, like the drum-memory machines of yesteryear.

Onward into the fog!

                                     Ed Nather
                                ...ihnp4!kpno!utastro!nather