Main Page | See live article | Alphabetical index

Data General Nova

Data General SuperNova'
The Nova was a popular 16-bit minicomputer built by Data General starting in 1968.

The Nova packed enough power to do most simple computing tasks into a single rack mount case, and became hugely popular in science labs around the world. Eventually 50,000 would be sold. Data General attempted to follow up the success of the Nova with a number of larger machines, but none of them were nearly as popular and Data General faded from the scene in the 1980s.

Edson deCastro was the Product Manager of the famous PDP-8 machine at DEC, generally considered by most to be the first true minicomputer. However deCastro was convinced it could be done even better, and left DEC to form Data General in 1968. The next year they released the Nova at a base price of US$3,995 as the best small computer in the world, and soon Nova's were being sold in the tens per minute.

The big innovations of the Nova were not technical as much as packaging. Primarily the entire machine was built onto a single 15 inch by 15 inch printed circuit board, which could then be run off an assembly line with no wiring required. This greatly reduced costs over the PDP-8, which consisted of several boards and modules that had to be wired together by hand. This also made the Nova more reliable, which served it well in the lab setting.

The first models were available with 4K of core memory as an option, one that practically everyone had to buy, bringing the system cost to $7,995. Even here DG managed to innovate, packing several planes of very small core into a rectangular box lying along the left side of the case. Up to 32K could be supported in an external expansion box. Semiconductor ROM was already available at the time, and RAM-less systems with ROM-only became popular in industrial settings. The original Nova machines ran at 1.5MHz, but the series was soon upgraded with semiconductor RAM which allowed DG to create the 3MHz SuperNova.

The standardized backplane and I/O signals that implemented a simple but effective I/O design made interfacing programmed I/O and Data Channel devices simple compared to other machines of the day. The backplane had wirewrap pins that could be used for non-standard connectors or other special purposes.

The Nova had four 16-bit accumulator registers, of which two could be used as index registers. There was a 15-bit program counter and a single-bit Carry register. As for the PDP-8, current + zero page addressing was central. The instruction format could be broadly categorized into one of three functions: 1) register-to-register manipulation, 2) memory reference, and 3) input/output. Each instruction was contained one word. The register-to-register manipulation was almost RISC-like in its bit efficiency; and an instruction that manipulated register data could also perform tests, shifts and even elect to discard the result.

The Nova's biggest competition was from the newly-born DEC PDP-11 computer series, and to a lesser extent the venerable DEC PDP-8 systems. Some have said that the Nova was pretty crude compared to its competitors, but it was quite effective and very fast for its day, at least at this low-cost end of the market. In fact, the SuperNova computer's 300 nanosecond cycle time was the fastest minicomputer for over a decade following its introduction. The Nova influenced the design of both the Xerox Alto (1973) and Apple I (1976) computers. Its external design has been reported to be the direct inspiration for the front panel of the MITS Altair (1975) microcomputer.

As of 2003 there are still 16-bit Novas and Eclipsess running in a variety of applications worldwide. There is a diverse but ardent group of people worldwide who restore and preserve legacy 16-bit Data General systems, and a web search of [Data General Nova], [Eclipse], [RDOS], or the various other DG-related keywords should yield good results.

Table of contents
1 Assembly language examples
2 External links

Assembly language examples

Hello, world

This is a minimal programming example in Nova assembly language. It is designed to run under RDOS and prints the string "Hello, world." on the console. 
	; a "hello, world" program for Nova running RDOS, by Toby Thain
	; uses PCHAR system call
	.titl hello
	.nrel
	.ent start

start:	
dochar:
	lda 0,@pmsg	; load ac0 with next character,
	mov# 0,0,snr	; test ac0; skip if nonzero (don't load result)
	jmp done
	.systm
	.pchar		; print first
	jmp er	; skipped if OK
	movs 0,0	; swap bytes
	.systm
	.pchar		; print second
	jmp er	; skipped if OK
	isz pmsg	; point to next word
	jmp dochar	; go around again

done:	.systm		; normal exit
	.rtn
er:	.systm		; error exit
	.ertn
	halt

pmsg:	.+1 ; pointer to first word of string
	; note bytes are packed right-to-left by default
	.txt /Hello, world.<15><12>/ ; that's CR LF
	0 ; flag word to end string

	.end start

16-bit multiply

Some models of the Nova lacked hardware multiply and divide. Here is a routine to multiply two 16-bit words to produce a 16-bit word result (overflow is ignored). It demonstrates combined use of ALU op, shift, and test (skip). Note that when this routine is called by jsr, AC3 holds the return address. This is used by the return instruction jmp 0,3. An idiomatic way to clear an accumulator is sub 0,0. Other single instructions can be arranged to load a specific set of useful constants (e.g. -2, -1, or +1). 
mpy:	; multiply AC0 <- AC1 * AC2, by Toby Thain
	sub 0,0		; clear result
mbit:	movzr 1,1,szc	; shift multiplier, test lsb
	add 2,0		; 1: add multiplicand
	movzl 2,2,szr	; shift and test for zero
	jmp mbit	; not zero, do another bit
	jmp 0,3		; return

Print accumulator in binary

The following routine prints the value of AC1 as a 16 digit binary number, on the RDOS console. It reveals further quirks of the Nova instruction set. For instance, there is no instruction to load an arbitrary "immediate" value into an accumulator (although memory reference instructions do encode such a value to form an effective address). Accumulators must generally be loaded from initialised memory locations (e.g. n16). Other contemporary machines such as the PDP-11, and practically all modern architectures, allow for immediate loads.

Because AC3 is not preserved by the RDOS .systm call, a temporary location is needed to preserve the return address. (For a recursive or otherwise re-entrant routine, the stack must be used instead.) The return instruction becomes jmp @ retrn which exploits the Nova's indirect addressing mode to load the return PC.

The constant definitions at the end show two assembler features: the assembler radix is octal by default (20 = sixteen), and character constants could be encoded as e.g. "0. 

pbin:	; print AC1 on console as 16 binary digits, by Toby Thain
	sta 3,retrn	; save return addr
	lda 2,n16	; set up bit counter
loop:	lda 0,chr0	; load ASCII '0'
	movzl 1,1,szc	; get next bit in carry
	inc 0,0		; bump to '1'
	.systm
	.pchar 		; AC0-2 preserved
	jmp err ; if error
	inc 2,2,szr	; bump counter
	jmp loop	; loop again if not zero
	lda 0,spc	; output a space
	.systm
	.pchar
	jmp err ; if error
	jmp @ retrn
spc:	" ;that's a space
chr0:	"0
n16: 	-20
retrn:	0

Using simh to emulate a Nova

Nova assembly language programs can be run under Bob Supnik's simh emulator, in RDOS. Of the above examples, only Hello, world is a complete program. It includes the necessary directives for a successful assembly and runnable program.

Start the Nova emulation and boot RDOS following the instructions under Nova and Eclipse RDOS in file src/simh_swre.txt in the simh distribution. The command prompt is R.

The first step is to create the assembly source file under RDOS. The xfer command will accept input at the console and copy it to a disk file named test.sr. After entering the command above, copy and paste or type in a complete assembly language program, and finish with control-Z: 

xfer/a $tti test.sr
Next, run the macro assembler on test.sr to create the object file test.rb; the /l (slash-ell) option enables the listing file, test.lst. The listing can be copied to the console using the command type test.lst 
mac/l test
The relocatable loader, rldr, takes the object file and creates the executable test.sv: 
rldr test
Now run it: 
test
Good luck! If you plan to do much experimentation, it can be convenient to check your program using a compatible cross-assembler such as dpa before taking it to the RDOS environment.

Hints

mac/s nbid osid nsid paru

External links