- Data General Nova
The Data General Nova was a popular 16-bit minicomputer built by the American company Data General starting in 1969. The Nova was packaged into a single rack mount case and had enough power to do most simple computing tasks. The Nova became popular in science laboratories around the world, and eventually 50,000 units were sold. It was succeeded by the Data General Eclipse, which was similar in most ways but added virtual memory support and other features required by modern operating systems.
- 1 History
- 2 Technical description
- 3 Assembly language examples
- 4 Emulating a Data General Nova
- 5 Facts
- 6 References
- 7 External links
de Castro and the Nova’s origin
Edson de Castro was the Product Manager at Digital Equipment Corporation (DEC) of their pioneering PDP-8, a 12-bit computer generally considered by most to be the first true minicomputer. De Castro was convinced, however, that it was possible to improve upon the PDP-8 by building a 16-bit minicomputer on a single board. Ken Olsen was not supportive of this project, so de Castro left DEC along with another hardware engineer, Richard Sogge, and a software engineer, Henry Burkhardt III, to found Data General (DG) in 1968. The fourth founder, Herbert Richman, had been a salesman for Fairchild Semiconductor and knew the others through his contacts with Digital Equipment.
In keeping with the original concept, the Nova was based on two 15 by 15 inches (38 × 38 cm) printed circuit boards, one for the CPU and another for various support systems. The design was laid out so it could be connected together with no manual wiring at all, allowing the boards to be built in a completely automated fashion. This greatly reduced costs over the rival PDP-8 and PDP-8/I, which consisted of many smaller boards that had to be wired together. The larger-board construction also made the Nova more reliable, which made it especially attractive for industrial or lab settings. Fairchild Semiconductor provided the medium-scale integration (MSI) chips used throughout the system. The Nova was one of the first 16-bit minicomputers and was a leader in moving to word lengths that were multiples of the 8-bit byte.
DG released the Nova in 1969 at a base price of US$3,995, advertising it as "the best small computer in the world." The basic model was not very useful out of the box, and adding RAM in the form of core memory typically brought the price up to $7,995. In 1969, Data General shipped a total of 50,000 Novas at $8000 each. The Nova’s biggest competition was from the new DEC PDP-11 computer series, and to a lesser extent the older DEC PDP-8 systems. It has been said that the Nova was crude compared to its competitors; but it was quite effective and very fast for its day, at least at its low-cost end of the market.
A further improvement on the Nova design followed the next year, the SuperNOVA. The SuperNOVA included a number of improvements that dramatically improved performance over the original model. This included the use of ROM for library software that could be run much faster than the same code in the normal core memory, due to the latter’s need to be written immediately after being read. Additionally the system included a new set of core with an 800 ns cycle time, faster than the original’s 1200 ns version. Finally the SuperNOVA also replaced the earlier model’s 4-bits-at-a-time math unit with a new 16-bit parallel version, speeding math by up to four times.
Soon after the introduction of the SuperNOVA, the SuperNOVA SC was introduced, featuring semiconductor (SC) memory in place of core. The much higher performance memory allowed the CPU, which was synchronous with memory, to be further increased in speed to run at a 300 ns cycle time (3.3 MHz), which made it the fastest minicomputer for over a decade following its introduction.
Further improvements in the line followed in 1970/1 with a pair of machines that replaced the Nova/SuperNOVA, the Nova 1200 and Nova 800 series. The 1200 used 1200 ns core while the 800 featured the SuperNOVA’s 800 ns core, explaining the somewhat confusing naming where the lower number represents the faster machine. Like the earlier models, the 1200 used a 4-bit math unit while the 800 used the SuperNOVA’s 16-bit unit. Both models were offered in a variety of cases, the 1200 with seven slots, the 1210 with four and the 1220 with fourteen. The 840, first offered in 1973, also included a new paged memory system allowing for addresses of up to 17-bits. An index offset the base address into the larger 128 kWord memory. Actually installing this much memory required considerable space; the 840 shipped in a large 14-slot case.
The next version was the Nova 2, with the first versions shipping in 1973. The Nova 2 was essentially a simplified version of the earlier machines as increasing chip densities allowed the CPU to be reduced in size. While the SuperNOVA used three 15×15" boards to implement the CPU and its memory, the Nova 2 fitted all of this onto a single board. ROM was used to store the boot code, which was then copied into core when the “program load” switch was flipped. Versions were available with four, seven and ten slots.
The Nova 3 of 1975 added two more registers, used to control access to a built-in stack. The processor was also re-implemented using TTL components, further increasing the performance of the system. The Nova 3 was offered in four-slot (the Nova 3/4) and twelve-slot (the Nova 3/12) versions.
It appears that Data General originally intended the Nova 3 to be the last of its line, planning to replace the Nova with the later Eclipse machines. However, continued demand led to a Nova 4 machine, this time based on four AMD 2901 bit-slice ALUs. This machine was designed from the start to be both the Nova 4 and the Eclipse S/140, with different microcode for each. A floating-point co-processor was also available, taking up a separate slot. An additional option allowed for memory mapping, allowing programs to access up to 128 kWords of memory using bank switching. Unlike the earlier machines, the Nova 4 did not include a front panel console and instead relied on the terminal to emulate a console when needed.
There were three different versions of the Nova 4, the Nova 4/C, the Nova 4/S and the Nova 4/X. The Nova 4/C was a single-board implementation that included all of the memory (16 or 32 kWords). The Nova 4/S and 4/X used separate memory boards. The Nova 4/X had the on-board memory management unit (MMU) enabled to allow up to 128 kWords of memory to be used (the MMU was also installed in the Nova 4/S, but was disabled by firmware). Both the 4/S and the 4/X included a “prefetcher” to increase performance by fetching up to two instructions from memory before they were needed.
Data General also produced a series of single-chip implementations of the Nova processor as the microNOVA. Changes to the bus architecture limited speed dramatically, to the point where it was about one-half the speed of the original Nova. The original microNOVA with the “mN601” processor shipped in 1977. It was followed by the microNOVA MP/100 in 1979, which reduced the CPU to a single VLSI chip, the mN602. A larger version was also offered as the microNOVA MP/200, shipping the same year.
The microNOVA was later re-packaged in a PC-style case with two floppy disks as the Enterprise. Enterprise shipped in 1981, running RDOS, but the introduction of the IBM PC the same year made most other machines disappear under the radar.
The Nova influenced the design of both the Xerox Alto (1973) and Apple I (1976) computers, and its architecture was the basis for the Computervision CGP (Computervision Graphics Processor) series. Its external design has been reported to be the direct inspiration for the front panel of the MITS Altair (1975) microcomputer.
Data General followed up on the success of the original Nova with a series of faster designs. The Eclipse family of systems was later introduced with an extended upwardly compatible instruction set, and the MV-series further extended the Eclipse into a 32-bit architecture to compete with the DEC VAX. The development of the MV-series was documented in Tracy Kidder’s popular 1981 book, The Soul of a New Machine. Data General itself would later evolve into a vendor of Intel processor-based servers and storage arrays, eventually being purchased by EMC.
As of 2004[update] there are still 16-bit Novas and Eclipses running in a variety of applications worldwide, including air traffic control. There is a diverse but ardent group of people worldwide who restore and preserve legacy 16-bit Data General systems.
The Nova, unlike the PDP-8, was a load-store architecture. It had four 16-bit accumulator registers, of which two (2 and 3) could be used as index registers. There was a 15-bit program counter and a single-bit carry register. As with the PDP-8, current + zero page addressing was central. There was no stack register, but later Eclipse designs would utilize a dedicated hardware memory address for this function.
The earliest models of the Nova processed math serially in 4-bit packets, using a single 74181 bitslice ALU. A year after its introduction this design was improved to include a full 16-bit parallel math unit using four 74181s, this design being referred to as the SuperNova. Future versions of the system added a stack unit and hardware multiply/divide.
The Nova 4 / Eclipse S/140 was based on four AMD 2901 bit-slice ALUs, with microcode in read-only memory, and was the first Nova designed for DRAM main memory only, without provision for magnetic core memory.
Memory and I/O
This core memory board, Part Number 50823 D8 7504-14166, and with layout artwork copyrighted 1971 by DGC, was organized in planar fashion as four groups of four banks, each bank carrying two sets of core in a 64 by 64 matrix; thus there were 64 x 64 = 4096 bits per set, x 2 sets giving 8,192 bits, x 4 banks giving 32,768 bits, x 4 goups giving a total of 131,072 bits, and this divided by the machine word size of 16 bits gave 8,192 Words of memory.
The core on this 8K Word memory board occupied a centrally located 'board-on-a-board' 5.25" wide by 6.125" high and was covered by a protective plate. It was surrounded by the necessary support driver read-write-rewrite circuitry and epitomized the state of the art of core memory, soon to be replaced by solid state memory. Even here DG managed to innovate, packing this very small core and the corresponding support electronics onto a single standard 15 x 15-inch (380 mm) board. Up to 32K of such core RAM could be supported in one external expansion box. Semiconductor ROM was already available at the time, and RAM-less systems (i.e. with ROM only) became popular in many industrial settings. The original Nova machines ran at approximately 200 kHz, but its SuperNova was designed to run at up to 3 MHz when used with special semiconductor main memory.
The standardized backplane and I/O signals created a simple, efficient I/O design that made interfacing programmed I/O and Data Channel devices to the Nova simple compared to competing machines. In addition to its dedicated I/O bus structure, the Nova backplane had wire wrap pins that could be used for non-standard connectors or other special purposes.
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 in 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. Hardware options included an integer multiply and divide unit, a floating-point unit (single and double precision), and memory management.
The earliest Nova came with a BASIC interpreter on paper tape. As the product grew, Data General developed many languages for the Nova computers, running under a range of consistent operating systems. FORTRAN IV, ALGOL, Extended BASIC, Data General Business Basic, Interactive COBOL, and several assemblers were available from Data General. Third party vendors and the user community expanded the offerings with Forth, Lisp, BCPL, C, Algol, and other proprietary versions of COBOL and BASIC.
The Nova 1200 executed core memory access instructions (LDA and STA) in 2.55 microseconds (μs). Use of read only memory saved 0.4 μs. Accumulator instructions (ADD, SUB, COM, NEG, etc.) took 1.55 μs, MUL 2.55 μs, DIV 3.75 μs, ISZ 3.15-4.5 μs. On the later Eclipse MV/6000, LDA and STA took 0.44 μs, ADD, etc. took 0.33 μs, MUL 2.2 μs, DIV 3.19 μs, ISZ 1.32 μs, FAD 5.17 μs, FMMD 11.66 μs.
Assembly language examples
Hello world program
; 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 character jmp dochar ; go around again done: .systm ; normal exit .rtn er: .systm ; error exit .ertn halt pmsg: .+1 ; pointer to first character of string ; note bytes are packed right-to-left by default ; <15><12> denotes a CR LF pair. .txt /Hello, world.<15><12>/ 0 ; flag word to end string .end start
Basic models of the Nova came without built-in hardware multiply and divide capability, to keep prices competitive. The following routine multiplies 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
Binary print accumulator
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, although many such as ARM restrict the range of values that can be loaded immediately.
Because the RDOS .systm call macro implements a jsr, AC3 is overwritten by the return address for the .pchar function. Therefore a temporary location is needed to preserve the return address of the caller of this function. For a recursive or otherwise re-entrant routine, a stack, hardware if available, software if not, 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
Emulating a Data General 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 generation of a runnable program.
Start the Nova emulation and boot RDOS following the instructions under “Nova and Eclipse RDOS” in the file src/simh_swre.txt of the simh distribution. After booting, RDOS’ command prompt, R, should appear on the screen.
- Before the first assembly on a newly setup RDOS system, the macro assembler’s default symbol definitions need to be configured using the following command: mac/s nbid osid nsid paru
- Create the assembly source file under RDOS: xfer/a $tti test.sr (the xfer command will accept input at the console and copy it to a disk file named test.sr; after entering the command, copy and paste (or type in) a complete assembly language program, and finish with control-Z).
- Next, run the macro assembler on test.sr to create the object file test.rb: mac/l test (the /l [slash-ell] option enables the listing file test.ls, which can be copied to the console using the command type test.ls).
- The relocatable loader, rldr, takes the object file and creates the executable test.sv : rldr test
- To run the program, type test
Before going further with serious experimentation, it can be convenient to check one’s programs at the PC using a suitable cross-assembler, such as the portable PDP-8/DG Nova cross-assembler listed in the External links section, before attempting execution in the RDOS environment.
- To have a directory listing of all files with basename test, type list test.- (note the hyphen, RDOS’ wildcard character)
- Delete files with delete (this might be needed because xfer won’t replace an existing file)
- A running program can usually be interrupted with Control-A
- To exit RDOS, type release %mdir%
- Quit simh at its prompt with q
The Canadian Broadcasting Corporation in Montreal used the Nova 1200 for channel playout automation up until the late 80's. It was then replaced with refurbished Nova 4 units and these were in use until the mid 90's.
- Bob Supnik’s SimH project – Includes a basic Nova emulator in a user-modifiable package
- The portable C compiler includes a NOVA target.
- SimuLogic’s website – Attempts to archive everything DG plus provide free and commercial products
- A portable PDP-8 and DG Nova cross-assembler
- Carl Friend’s Minicomputer Museum – Describes the Nova instruction set in detail
Wikimedia Foundation. 2010.