andrew@orca.UUCP (07/04/83)
I can't believe that people are holding up the NOVA instruction set as
a design to be emulated! This is the machine where you cannot cram a
16-bit address into any sort of instruction; the most you have are four
flavors of short displacements: relative to either of two registers,
relative to PC, or located in low memory ("page zero"). The
convolutions you have to go through to write (or generate) machine code
are painful. You want to call a distant subroutine? Plant a pointer
to it, somewhere close to your "call" instruction, and do an indirect
reference. Duplication of commonly-used constants is rampant because
you can only refer to constants within plus-or-minus 128 words.
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).
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]wmb@sun.UUCP (Mitch Bradley) (07/15/83)
Another interesting "feature" of the Nova, as I recall, was related to the indirect bit in Nova addresses. It seems that if you constructed an address pointer that pointed to itself, and also had the indirect bit set, then the machine would go into an infinite loop that could only be terminated by turning off the power. Also a->b->c->....->a would accomplish the same effect.
padpowell@wateng.UUCP (PAD Powell[Admin]) (07/16/83)
Sorry to disapoint you, but the indirect loop terminated after 2 seconds.
This was done with a resistor and capacitor... I fondly recal a hardware
fault where indirection failed, and the repair man (Long before the days
of CE's) replaced it... Sigh... Those were the good old days when
Real Programmers could toggle in the bootstrap from memory...
Patrick ("Sigh. Paper Tape Operating System??? The last USENIX
conference seems to indicate UNIX will be the first
Red Tape and Blue Suit Operating System") Powellguy@rlgvax.UUCP (Guy Harris) (07/17/83)
UNIX the first "red tape and blue suit" operating system? If you mean "the
first operating system where you have to deal with lawyers and marketers and
bureaucracy to get it", not by a LONG shot. For all the bitches about the
problems that come with UNIX's commercial maturity, it's still not noticably
worse than the vast bulk of OSes out there.
Guy Harris
{seismo,mcnc,we13,brl-bmd,allegra}!rlgvax!guyfuka@parsec.UUCP (07/19/83)
#R:orca:-135800:parsec:32800002:000:1047
parsec!fuka Jul 11 16:12:00 1983
As a former programmer for Data General, I agree with most of what
orca!andrew has to say about the Nova. It WAS a real pain to write
software for, but the simple architecture made it cheap to produce out
of TTL in those days, which made it cheap to sell. Just like the RISC,
it was also fast (for the times) because it was such a simple
instruction set to decode. If you think about the concepts in RISC,
the Nova was actually a pretty far-sighted machine. That doesn't mean
that I'd ever want to program one again, however.
One minor point: The sixteenth bit of Nova addresses WAS used -- it
was an indirect bit, which allowed for n-way indirection of memory
references. Any indirect reference which found an indirect pointer
which had this bit set would cause a second level of indirection. Some
knock-off Nova manufacturers (AMPEX?) used this 'extra' bit to
implement a doubling of the address space (but only through indirect
addressing).
Kent Fuka
Parsec Scientific Computer Corp.
{allegra|ihnp4|uiucdcs}!parsec!fukanather@utastro.UUCP (07/21/83)
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