Data General Nova
The Data General Nova was a pioneering series of 16-bit minicomputers introduced in late 1968 by Data General Corporation, a company founded earlier that year by former Digital Equipment Corporation (DEC) engineers including Edson de Castro, who had led the PDP-8 design team.[1][2] Designed as a compact, general-purpose system for real-time and on-line applications, the original Nova featured a multi-accumulator architecture with four 16-bit accumulators (two indexable), a load/store design, and medium-scale integration (MSI) TTL logic circuits—making it one of the first minicomputers to incorporate 10 to 100 gates per integrated circuit for enhanced performance and reliability.[2][3] It supported up to 32K words (64 KB) of core memory with cycle times as low as 2.6 µs, 16 bidirectional I/O data lines capable of addressing up to 62 devices, and a high-speed direct memory access channel, all housed in a single rack-mount chassis consuming about 400 watts.[1][3] Priced starting at around $8,000 for a basic 32K configuration, the Nova offered competitive performance for its era, with a 1.8 µs instruction cycle and an extensive instruction set including over 100 operations for arithmetic, logical, shift, and skip functions, appealing to original equipment manufacturers (OEMs) through quantity discounts.[1][3] The system quickly gained popularity in scientific research, industrial control, data acquisition, educational settings, and process monitoring due to its modularity, ease of interfacing, and software support including assemblers, debuggers, and real-time operating systems like RDOS.[4][5] The Nova family evolved through the 1970s, spawning models like the Nova 2 (1973), Nova 3 (1975), and Nova 4 (1978), which maintained the core 16-bit architecture while adding features such as memory management units, faster semiconductors, and multiprocessing capabilities, ultimately influencing later personal computing designs including the Xerox Alto and Apple I.[1][5] By the late 1970s, Data General had delivered over 50,000 Nova systems, cementing its role in the minicomputer revolution before transitioning to 32-bit Eclipse and MV lines.[4]History
Founding and Origins
Data General Corporation was founded on April 15, 1968, by Edson de Castro, Richard Sogge, Henry Burkhardt III, and Herbert Richman, all former employees of Digital Equipment Corporation (DEC) except Richman from Fairchild Semiconductor.[6] The company was established in Hudson, Massachusetts, initially operating out of a rented beauty parlor, with the aim of entering the burgeoning minicomputer market.[7] De Castro, who had served as the product manager for DEC's influential PDP-8 minicomputer—a 12-bit system introduced in 1965—grew frustrated with DEC's direction. In late 1967, he proposed the PDP-X, a 16-bit minicomputer designed as a successor to the PDP-8, emphasizing compatibility, upgradability, and the use of emerging medium-scale integration (MSI) technology to capture a larger share of the market.[8] DEC's management rejected the PDP-X proposal, viewing it as too risky and incompatible with their existing product lines, prompting de Castro and his colleagues to leave the company.[6] This rejection directly inspired the conceptual roots of the Nova, positioned as a more advanced 16-bit alternative to the PDP-8, targeting similar applications but with improved performance and cost-efficiency.[8] The founders secured initial venture capital funding totaling $800,000, including contributions from American Research and Development Corporation and financial backer Frederick Adler, who invested $50,000 personally.[6][7] Their motivation was to develop a faster and cheaper minicomputer than DEC's offerings, leveraging monolithic integrated circuits to serve scientific and industrial markets underserved by larger mainframes like IBM's System/360.[6] The early team included de Castro for logic design and leadership, Burkhardt for software development, Sogge for memory and circuit design, and Herb Richman as vice president of sales.[6][7] Development of the Nova began in April 1968, with the first prototype completed by December 1968 for demonstration at the Fall Joint Computer Conference, and initial shipments occurring in February 1969.[6] The company went public later that year, raising an additional $5 million.[6]Initial Design and Introduction
The initial design of the Data General Nova stemmed from the engineering team's vision to create a cost-effective, high-performance 16-bit minicomputer that could outperform contemporaries like the PDP-8 while targeting real-time and on-line applications. Key goals included a load-store architecture with four 16-bit accumulators—two of which could function as index registers—to minimize memory accesses and enhance programming efficiency for tasks such as process control and data acquisition. This multi-accumulator approach addressed limitations in single-accumulator designs by allowing temporary data storage without frequent memory references, enabling faster execution of arithmetic and logical operations. The system supported a 15-bit address space, accommodating up to 32K words of memory, and prioritized simplicity and reliability for both original equipment manufacturers (OEMs) and direct end-users.[3][9] The Nova's central processor was implemented using discrete medium-scale integration (MSI) transistor-transistor logic (TTL) circuits, consolidated onto a single 15-inch by 15-inch printed circuit board to reduce costs and improve compactness compared to multi-board rivals. This single-board CPU design fit into a low-profile 5.25-inch-high rack-mount chassis, measuring 19 inches wide and 21.5 inches deep, which facilitated easy integration into industrial environments. Memory utilized magnetic core technology with a cycle time of 2.6 microseconds for access in a 4K configuration, corresponding to an approximate clock speed of 0.4 MHz, allowing basic operations like addition to complete at rates up to 384,615 per second. The architecture's emphasis on TTL avoided more expensive components like transformers in memory, contributing to the system's economy and efficiency.[3][9][10] Data General demonstrated a prototype of the Nova at the 1968 Fall Joint Computer Conference and commercially introduced it in 1969, marking its public debut as a revolutionary minicomputer priced at approximately $3,950 for the basic unit without memory or peripherals. The company positioned it as an affordable alternative to DEC systems, with full configurations including 4K words of core memory and interfaces costing around $8,000. First units shipped in February 1969, achieving rapid market traction; by 1970, Data General had delivered 700 Novas, demonstrating strong initial sales to OEMs for embedded applications and end-users in scientific and industrial settings. This success validated the design's focus on performance-per-dollar, helping establish Data General as a key player in the minicomputer industry.[11][9][10]Model Evolution
The SuperNOVA, introduced in 1970, represented the first significant upgrade to the original Nova design, achieving over three times the performance through the use of Schottky TTL logic and supporting direct memory access (DMA) for improved I/O efficiency.[12] It featured a core memory cycle time of 800 nanoseconds, with optional read-only memory enabling a 300-nanosecond cycle, and the SuperNOVA SC variant pioneered semiconductor memory in commercial minicomputers.[13] In 1971, Data General expanded its lineup with the cost-reduced Nova 1200 and Nova 800 models, targeted at entry-level markets and OEM applications.[14] These systems used slower magnetic core memory cycles of 1.2 microseconds for the Nova 1200 and 800 nanoseconds for the Nova 800, while maintaining compatibility with the original Nova's architecture to support 4K to 32K words of memory.[12] The Nova 2 series, launched in June 1973, incorporated more integrated medium-scale integration (MSI) logic to reduce component count and cost, available in 4-slot (Nova 2/4) and 10-slot (Nova 2/10) chassis configurations.[12] It offered memory cycle times of 1 microsecond or 800 nanoseconds with magnetic core up to 32K words, emphasizing affordability for industrial and laboratory use while preserving binary compatibility with earlier models.[14] Released in October 1975, the Nova 3 family advanced performance with semiconductor memory options, including a standard 700-nanosecond cycle time and compatibility across its variants like the 4-slot Nova 3/4, 12-slot Nova 3/12, and protected-memory Nova 3/D.[12] An optional cache-like high-speed memory board provided faster access, expanding capacity to 128K words and introducing memory protection for multi-user environments.[15] The Nova 4 series, announced in 1977, further increased integration with models such as the single-board Nova 4/C, higher-performance Nova 4/S, and extended Nova 4/X, supporting up to 1 MB of memory through advanced MOS semiconductor boards.[16] It achieved a 400-nanosecond memory cycle time on the CPU board, with options for multiply/divide hardware and real-time clock, while ensuring full backward compatibility with prior Nova software.[17] In 1977–1978, Data General introduced the microNOVA family for embedded applications, featuring single-chip processors like the mN601 (NMOS-based, 8.3 MHz clock) and later mN602 (Nova 4-compatible).[18] These emphasized serial I/O interfaces over parallel buses, with two 8-bit serial ports for simplified connectivity in distributed systems, and supported up to 128K words of memory.[19] By the early 1980s, the Nova family had sold over 50,000 units worldwide, establishing Data General as a leading minicomputer vendor during the 1970s.[20]Decline and Legacy
By the late 1970s, the Data General Nova faced intensifying competition from Digital Equipment Corporation's VAX line of 32-bit minicomputers, introduced in 1977, which offered greater addressable memory and processing power for emerging applications.[7] This shift toward 32-bit architectures contributed to declining sales of the 16-bit Nova, exacerbating Data General's financial difficulties as the market demanded more scalable systems.[7] In response, Data General pivoted to its Eclipse series, initially launched as a 16-bit successor in 1974 but expanded with the 32-bit Eclipse MV line by 1980 to directly challenge the VAX.[7] Production of Nova models effectively ceased around this time, marking the end of the line as the company focused on Eclipse for commercial and scientific computing.[21] The Nova's legacy endures as a cornerstone of the minicomputer revolution, democratizing access to powerful computing by delivering affordable 16-bit performance that rivaled larger systems at a fraction of the cost.[22] Its innovative single-board processor design and use of medium-scale integration circuits set benchmarks for reliability and compactness, inspiring competitors such as Prime Computer's 16-bit systems and Hewlett-Packard's HP 3000 series in the 1970s market.[22] By enabling widespread adoption in scientific, educational, and industrial settings, the Nova helped transition computing from mainframe dominance to distributed minicomputer environments.[2] Culturally, the Nova era shaped Data General's high-stakes engineering ethos, which Tracy Kidder chronicled in his 1981 Pulitzer Prize-winning book The Soul of a New Machine, detailing the intense development of the Eclipse MV/8000 but rooted in the innovative, deadline-driven culture forged during the Nova's rapid evolution.[23] In the 2020s, preservation efforts have revitalized interest in the Nova, with hobbyists undertaking restorations such as the 2024 Hackaday project on a Nova II system deployed in Arctic research environments.[24] YouTube channels like Tech Tangents have documented repairs and software revival for the 1975 microNOVA variant, culminating in a functional demonstration video on May 24, 2025.[25] Online resources, including the datageneral.uk archive, provide extensive documentation, schematics, and emulator tools to support community-driven maintenance of Nova hardware.[26] The Nova's accumulator-based architecture, featuring four 16-bit accumulators for efficient data manipulation, influenced early microprocessor designs by emphasizing compact, versatile register sets that echoed in accumulator-centric chips like the Intel 8080.[27] This conceptual foundation contributed to the transition from minicomputers to personal computing, with Nova-inspired elements appearing in systems like the Xerox Alto and early Apple prototypes.[28]Architecture
Processor Design
The Data General Nova processor employed a 16-bit word architecture, enabling efficient handling of data in whole words rather than bytes, which accelerated memory transfers and arithmetic operations.[3] At its core, the design featured four 16-bit accumulators, designated AC0 through AC3, which served as the primary registers for data manipulation and temporary storage.[29] AC2 and AC3 could additionally function as index registers to support indirect addressing modes.[30] The processor also included a 15-bit program counter for sequencing instructions, limiting the initial address space to 32,768 words (64 KB of storage).[31] The Nova adopted a load-store architecture, distinguishing it from register-memory designs prevalent in contemporaries like the PDP-8; memory access instructions (such as load and store) were separate from arithmetic and logic unit (ALU) operations, promoting a cleaner separation of data movement and computation.[31] This structure required explicit loads to transfer data from memory into the accumulators before ALU processing could occur, enhancing modularity but increasing instruction counts for complex tasks.[30] The ALU supported fundamental operations including addition, subtraction, logical AND, OR, and XOR, all performed between accumulators or an accumulator and immediate values, with results stored back in the accumulators and a single-bit carry flag for overflow detection.[29] Early models relied on hardwired control logic implemented with transistor-transistor logic (TTL) integrated circuits, providing straightforward execution paths for these operations.[30] Later iterations, particularly the Nova 4 introduced in 1978, incorporated horizontally microcoded control to enable instruction prefetching and overlap, improving efficiency through more flexible sequencing of micro-operations.[16] Clock speeds evolved significantly across the Nova family, reflecting advances in semiconductor technology and memory integration. The original Nova (1969) operated with a basic cycle time of approximately 2.6 microseconds using core memory, constrained by TTL circuitry.[3] The Nova 1200 (1970) improved to a 1.2-microsecond memory cycle time, still based on TTL.[27] Subsequent models like the SuperNova (1970) achieved around 800 nanoseconds, while the Nova 3 (1975) used NMOS technology for cycle times around 700 nanoseconds.[30] The Nova 4 culminated this progression with a 400-nanosecond cycle time, leveraging NMOS and four-way memory interleaving for sustained high performance.[32] Central to the processor's design was a multiplexed address/data bus in the core, which shared lines for both addressing memory and transferring data, optimizing pin count and board space in the compact chassis while supporting direct memory access (DMA) for I/O devices.[30] This bus structure integrated seamlessly with the load-store paradigm, facilitating efficient communication between the CPU and memory subsystems.Memory and I/O Systems
The Data General Nova initially featured magnetic core memory, with standard configurations ranging from 4 KB to 16 KB.[30] Later models transitioned to semiconductor RAM for improved speed and reliability, beginning with the SuperNOVA in 1970; the Nova 2 series supported up to 64 KB and expanding to 1 MB in the Nova 4 series.[30] This shift allowed for larger addressable spaces while maintaining compatibility with existing core-based systems in hybrid configurations on select models like the Nova 3/12 and 3/D.[30] Memory addressing in the Nova supported direct access to a 32 KB address space using 15-bit logical addresses from the processor.[30] For expansion beyond this limit, memory banking was implemented via the Memory Management Unit (MMU) or Memory Management and Protection Unit (MMPU), which divided memory into 1K-word pages and enabled bank switching to access up to 128 K words.[30] Later models, such as the Nova 3 NMOS variants, included optional parity bits—one per 16-bit word—for error detection, while the MMPU in the Nova 3/D added protection features like memory access validation, I/O safeguards, and runaway deferral to prevent unauthorized or erroneous operations.[30] The Nova's I/O system utilized 6 to 12 direct channels, configurable through the system's backplane slots, allowing programmable interfacing with external devices.[30] A standard Direct Memory Access (DMA) channel was included across all models for efficient data transfers between memory and peripherals, with enhancements in the SuperNOVA and later series providing higher-speed options up to 1 MHz transfer rates in the Nova 4.[30][33] Standard peripherals connected via these channels included teletypes for console interaction, paper tape readers and punches operating at speeds up to 400 characters per second, and disk drives with capacities such as 25 MB fixed-head units or cartridge-based subsystems akin to the RL01 format offering 10 MB per drive.[30][33] Custom expansion boards were also supported for industrial control applications, integrating sensors and actuators directly into the I/O framework.[30] System expansion relied on a modular backplane design within 19-inch rack-mountable chassis, accommodating up to 20 slots for memory, I/O, and processor modules, with options for additional chassis to extend capacity in larger configurations like the Nova 3/12's 12-slot base.[30] The processor bus connected these modules, facilitating shared access to memory and I/O resources without requiring extensive rewiring.[30]Programming Model
The programming model of the Data General Nova centered on a minimalist register set designed for efficient 16-bit operations, emphasizing accumulators for data manipulation and control. The original Nova processors featured four 16-bit accumulator registers (AC0 through AC3), which served as the primary locations for arithmetic, logical, and data transfer operations; AC2 and AC3 could additionally function as index registers for addressing. A 15-bit program counter (PC) managed instruction fetching, while a single-bit carry flag (often denoted as CRY) captured overflow from arithmetic and logical instructions. There was no dedicated skip flag register; instead, skip conditions were handled via conditional instructions that incremented the PC by two, effectively skipping the next instruction based on flags like zero, carry, or sign. Later models, such as the Nova 3 introduced in 1975, extended this set with a 15-bit stack pointer (SP) and frame pointer (FP) to support hardware-managed stacks, maintaining backward compatibility with earlier code.[29][30][34] Addressing in the Nova was flexible yet constrained to a 15-bit memory space (32,768 words), with modes optimized for locality and indirection to minimize instruction size. Direct addressing used an 8-bit displacement field (octal 000 to 377, or -128 to +127 in signed interpretation) relative to the current page or page zero, allowing access to 256 words without additional overhead. Indirect addressing enabled deferred resolution by fetching the effective address from memory, supporting multi-level indirection up to eight levels in some implementations. Autoindexing (or indexed addressing) added the signed displacement to the contents of AC2 or AC3 before accessing memory, facilitating array traversal; deferred indirect combined indirection with indexing for complex pointer operations. These modes were encoded in the instruction's upper bits, with the X field (bits 13-12) selecting between page zero/relative (00/01) and indexed via AC2/AC3 (10/11).[29][35][30] Stack operations relied on software conventions in early Nova models, as there was no hardware stack pointer initially; programmers typically used AC3 or dedicated memory locations (e.g., octal 0 and 1 for interrupt vectors) for temporary storage and returns. The Jump to Subroutine (JSB) instruction provided hardware support by storing the return address (PC+1) in AC3 and jumping to the target, enabling nested calls through software stack management; interrupts did not automatically use the stack, requiring explicit handler saves. With the Nova 3, hardware stacks became integral, using the SP to point to the top of a 256-word LIFO region in memory for push/pop operations, while the FP delimited frames for local variables and parameter passing during subroutines—enhancing efficiency without altering base JSB semantics. This evolution preserved subroutine compatibility across the family.[29][35][34] The Nova handled data primarily as 16-bit two's-complement signed integers or unsigned logical words, with no native byte operations—bytes were extracted via masking and shifting within words, assuming big-endian layout. Arithmetic and logical instructions operated on these full words, supporting addition, subtraction, AND, OR, and shifts, with the carry flag propagating for multi-word operations. Floating-point arithmetic was absent in hardware and emulated in software using double-word (32-bit) formats with a 7-bit exponent and 24-bit mantissa, or extended 64-bit versions; such emulation was common in scientific applications but incurred performance overhead.[29][30] Binary compatibility was a cornerstone of the Nova design, ensuring that object code from earlier models (e.g., original Nova or Nova 2) executed unchanged on successors like the Nova 3 or microNOVA, as extensions such as the stack registers and new instructions were optional and did not modify the core 16-bit architecture or base instruction encoding. This allowed seamless upgrades in deployments, with later processors emulating any missing features via microcode where needed.[30][29]Instruction Set
The Data General Nova's instruction set is designed for a 16-bit architecture, where each instruction occupies a single 16-bit word. The high three bits (bits 15-13) typically determine the instruction class: 000 for memory reference instructions (with low 13 bits encoding operation, addressing mode, and an 8-bit displacement), 011 for I/O instructions (with low 13 bits specifying accumulator, transfer type, control action, and a 6-bit device code), and arithmetic/logical instructions identified by bit 0 set to 1 (with bits 15-1 encoding source/destination accumulators, operation, shifts, carry handling, and skip conditions). Addressing modes for memory reference include direct (page zero or current page), indexed (using AC2 or AC3), and indirect, supporting a 12-bit effective address range. The base set comprises approximately 50 instructions through combinations of these fields, without exposure of underlying microcode operations.[29]Memory Reference Instructions
These instructions handle data movement between memory and the four accumulators (ACs), as well as program flow control and memory modification, operating on the specified effective address computed from the displacement and mode bits (bits 8-10: 00 for page zero unsigned, 01 for current page signed, 10 for AC2 index, 11 for AC3 index; bit 7 for indirect if set). They form the core of load/store and branching operations in the programming model.| Mnemonic | Octal Opcode Prefix | Format (Bits 15-13 = 000) | Behavior |
|---|---|---|---|
| JMP | 000 [mode] [disp] | Bits 12-10 = 000 | Unconditional jump to effective address; PC set to that location. |
| JSR | 001 [mode] [disp] | Bits 12-10 = 001 | Jump to subroutine: PC + 1 stored in AC3, then jump to effective address. |
| ISZ | 010 [mode] [disp] | Bits 12-10 = 010 | Increment memory at effective address by 1; skip next instruction if result is zero. |
| DSZ | 011 [mode] [disp] | Bits 12-10 = 011 | Decrement memory at effective address by 1; skip next instruction if result is zero. |
| LDA | [AC]00 [mode] [disp] | Bits 15-13 = 000, bits 12-10 encode AC and load (e.g., 000 for AC0 LDA), bit 9 = indirect, bits 8-7 = mode (00 page zero, 01 current page, 10 AC2 index, 11 AC3 index), bits 7-0 = 8-bit signed displacement | Load contents of effective address into specified AC; memory unchanged. |
| STA | [AC]01 [mode] [disp] | Bits 15-13 = 000, bits 12-10 encode AC and store (e.g., 100 for AC0 STA), bit 9 = indirect, bits 8-7 = mode (00 page zero, 01 current page, 10 AC2 index, 11 AC3 index), bits 7-0 = 8-bit signed displacement | Store contents of specified AC into effective address; AC unchanged. |
I/O Instructions
I/O instructions manage data transfer and control signals to up to 64 peripheral devices, using three 16-bit buffers (A, B, C) per device. The format specifies the accumulator (bits 12-11), transfer type (bits 10-8), control action (bits 7-6: 00 none, 01 set busy/clear done, 10 clear busy/done, 11 pulse), and device code (bits 5-0, octal 00-77). Transfers move data between the AC and the selected buffer; skips test device status flags (busy or done). The CPU is treated as device 77 for control functions.| Mnemonic | Octal Prefix | Transfer (Bits 10-8) | Behavior |
|---|---|---|---|
| DIA | 3[AC]1 [ctrl] [dev] | 001 | Input data from device buffer A to specified AC. |
| DOA | 3[AC]2 [ctrl] [dev] | 010 | Output data from specified AC to device buffer A. |
| DIB | 3[AC]3 [ctrl] [dev] | 011 | Input from buffer B to AC. |
| DOB | 3[AC]4 [ctrl] [dev] | 100 | Output from AC to buffer B. |
| DIC | 3[AC]5 [ctrl] [dev] | 101 | Input from buffer C to AC. |
| DOC | 3[AC]6 [ctrl] [dev] | 110 | Output from AC to buffer C. |
| SKP | 3[AC]7 [cond] [dev] | 111 | Skip next instruction based on condition: 00 if busy=1 (SKPBN), 01 if busy=0 (SKPBZ), 10 if done=1 (SKPDN), 11 if done=0 (SKPDZ). |
Arithmetic and Logical Instructions
These operate on the four 16-bit accumulators, performing fixed-point arithmetic and bitwise logic between source and destination ACs (bits 1-2 source, bits 3-4 destination). Bit 0 = 1 identifies the class. Additional fields include function (bits 5-7), shift (bits 8-9: 00 none, 01 rotate left 1, 10 rotate right 1, 11 swap bytes), carry control (bits 10-11: 00 ignore, 01 clear to 0, 10 set to 1, 11 complement), skip control (bits 13-15 encoding 8 conditions like always skip, skip if result zero, skip if carry set), and a no-load bit (bit 12=1 to skip loading destination). Results may affect a 1-bit carry flag.| Mnemonic | Function (Bits 5-7) | Behavior |
|---|---|---|
| ADD | 000 | Destination += source (+ carry if set); supports signed/unsigned. |
| SUB | 001 | Destination -= source (+ carry if set). |
| AND | 010 | Destination = destination AND source. |
| IOR | 011 | Destination = destination OR source (inclusive). |
| XOR | 100 | Destination = destination XOR source. |
| COM | 101 | Destination = ~source (complement). |
| NEG | 110 | Destination = -source (two's complement negate). |
| MOV | 111 | Destination = source (move). |
| INC | 011 (variant) | Destination += 1 (increment). |
| CLR | 000 (with clear) | Destination = 0 (clear). |
Special and Control Instructions
Special instructions are encoded as I/O instructions to the CPU device (octal 77) or operate variants, handling system control without memory reference. They include no-operation (NOP, operate with MOV AC0 to AC0 and no skip), halt (HLT: DOC 00 to device 77, stopping execution), and shifts like SHL/SHR (via rotate controls in operate). Interrupt enable/disable (INTEN/INTDS: NIO S/C to 77), mask set (MSKO: DOB to 77), and acknowledge (INTA: DIB from 77, loading vector to AC) manage the interrupt system. Read switches (READS: DIA from 77 to AC) loads front-panel data. These ensure basic system management within the base set.[29]System Features
Interrupts and Handling
The Data General Nova featured a 16-level priority interrupt system designed to handle input/output operations efficiently, with levels numbered 0 through 15.[36] Each level corresponded to a bit in a 16-bit interrupt mask register, allowing software to enable or disable interrupts selectively by setting or clearing the appropriate mask bits using the MSKO instruction.[34] Devices were assigned to specific levels based on their wiring to the I/O bus positions, ensuring prioritized handling where higher levels (lower numerical values) took precedence.[36] Interrupt requests were managed through a hardware daisy-chain mechanism on the I/O bus, where devices were connected in series to establish priority among those at the same level; the device closest to the processor in the chain gained access first if multiple requests occurred simultaneously.[37] The ION (Interrupt On) and IOFF (Interrupt Off) instructions, encoded as NIO S 0,CPU (octal 060177) and NIO C 0,CPU (octal 060277) respectively, controlled the global interrupt enable flag, disabling further interrupts upon entry to a handler to prevent nesting until explicitly re-enabled.[29] Upon an interrupt occurrence, the hardware automatically saved the program counter (PC) to memory location 0 (octal) and performed an indirect jump through location 1 (octal) to the start of the common interrupt handler routine.[29] For handling across the 16 levels, the common routine dispatched to level-specific handlers using software pointers in page zero, based on the interrupting level determined from the device or mask.[29] The handler then performed a software context save, storing the accumulator registers (AC0-AC3), carry flag, and other state to a designated area, as the hardware provided no automatic stacking beyond the PC; restoration occurred symmetrically before returning via a JMP instruction to the saved PC.[37] In the SuperNOVA model, direct memory access (DMA) operations integrated seamlessly with the interrupt system, using dedicated data channels that could request interrupts upon transfer completion or error, maintaining priority over standard program interrupts while adhering to the same mask and daisy-chain protocols.[38] Additionally, a non-maskable power-fail interrupt was provided via an optional power monitor circuit, which detected impending power loss and forced an interrupt to allow software to perform emergency saves during the brief delay before shutdown, bypassing the standard mask and daisy-chain.[34] This design, while efficient for its era, imposed limitations such as reliance on software for complete context management in multilevel scenarios, potentially increasing handler latency in complex environments.[37]Front Panel and Diagnostics
The front panel of early Data General Nova models, such as the Nova 1200, provided a direct physical interface for manual system operation and troubleshooting, featuring a row of 16 LEDs (or incandescent lamps in early models) that displayed memory or register contents in binary format for visual inspection of 16-bit words. Complementing this were 16 toggle sense switches positioned below the grid, used to set specific addresses or data values for entry into the system. These elements allowed operators to interact with the machine at a low level, examining and modifying internal states without external peripherals.[39] Key controls on the panel included push-button switches for EXAM/DEP (examine/deposit), which enabled reading the contents of a selected memory location or register onto the LED display and writing values from the sense switches into memory, respectively; RUN/STEP for initiating continuous program execution or single-stepping through instructions; RESET to halt the processor and clear pending operations; and an interrupt enable button to arm the system for external signals. Accumulator selector switches (for AC0 through AC3) worked in conjunction with the deposit and examine functions, directing sense switch inputs to specific registers or displaying their values on the LEDs. For instance, activating the AC0 deposit switch loaded the sense switch pattern directly into accumulator 0, while the examine counterpart transferred the accumulator's contents to the display.[40][41] Diagnostics were integrated into the panel through dedicated error lights signaling conditions like memory parity failures, carry overflow, or direct channel activity, providing immediate visual feedback on hardware issues. Built-in exercisers for memory and CPU testing could be invoked via panel controls, cycling through read/write patterns to detect faults in core memory or processor logic without requiring software intervention. User interaction extended to bootstrap loading, where operators manually entered a short loader routine using the sense switches and deposit functions to initialize the system from paper tape readers or ROM-based devices, establishing the initial program counter before full operation.[41][24] Subsequent models simplified the front panel design to reduce complexity and cost. The Nova 3, for example, employed a more compact layout with a single row of 16 data LEDs, status indicators for run mode, memory power, parity errors, and interrupt conditions, and streamlined toggle switches for essential examine/deposit and step operations, while retaining compatibility with core functions. In the embedded microNOVA variant, the panel became optional, often replaced by a compact hand-held unit featuring only power/reset/run switches, basic indicator lights, and minimal data entry capabilities to suit space-limited applications.[41][42]Performance Characteristics
The Data General Nova series exhibited progressive improvements in performance across its models, primarily through reductions in memory cycle times and enhancements in instruction execution efficiency. The original Nova, introduced in 1969, featured a core memory cycle time of 2.6 microseconds per word, enabling basic fixed-point arithmetic operations such as addition in approximately 5.9 microseconds.[36] Subsequent iterations accelerated this: the Nova 1200 series reduced the cycle time to 1.2 microseconds, the Nova 2 series to 1.0 microsecond, and the Nova 800 and Supernova models to 0.8 microseconds for core memory, with bipolar semiconductor options in the Supernova achieving 0.3 microseconds.[36] By the Nova 4, released in 1978, the cycle time reached 400 nanoseconds with four-way memory interleaving, allowing typical instruction executions like stores in 400 nanoseconds and adds in 200 nanoseconds.[43] These advancements translated to effective throughput rates approaching 0.5 million instructions per second (MIPS) for basic operations in later models, though actual performance varied with memory type and workload.[36] Benchmark results underscored the Nova's capabilities relative to its era. In Whetstone benchmarks, which measure floating-point performance, the original Nova achieved around 0.016 million Whetstone instructions per second (MWIPS) using software-implemented floating-point arithmetic, scaling to 0.068 MWIPS with hardware support in models like the Nova 840.[44] The Nova 3/12 variant performed at 0.014 MWIPS in Fortran single precision, while later Eclipse derivatives (successors to the Nova line) reached 0.45 MWIPS with hardware floating-point, representing roughly a 4x improvement over the original Nova.[44] Direct memory access (DMA) throughput also improved, from 285,500 words per second input in the Nova 800 to 1.25 million words per second in Supernova models with high-speed options.[36] Compared to contemporaries, the Nova series provided superior integer mathematics performance over the DEC PDP-8, benefiting from its 16-bit architecture versus the PDP-8's 12-bit design, which enabled roughly 2-3 times faster processing for equivalent tasks at similar cycle times.[45] It remained cost-competitive with the DEC PDP-11, offering about 40% lower pricing for comparable configurations while delivering equivalent or better price/performance in real-time applications.[36] Key performance factors included initial memory access latencies of 800 nanoseconds in early core-based systems, reduced to 700 nanoseconds in Nova 3 semiconductor memory, which minimized bottlenecks in compute-intensive workloads. Later models like the Supernova incorporated overlapped fetch-execute cycles, further boosting effective speed by up to 50% over predecessors.[13] Power consumption typically ranged from 175 to 725 watts across configurations, averaging around 500 watts for a fully equipped rack-mounted system, which supported efficient deployment in laboratory and industrial environments with standard single-phase power.[30] This heat dissipation, while manageable via rack ventilation, highlighted the trade-offs of TTL-based logic in 1970s minicomputers.[46]| Model | Memory Cycle Time | Example Add Time (Fixed-Point) | Relative Performance (vs. Original Nova) |
|---|---|---|---|
| Original Nova | 2.6 μs | 5.9 μs | 1.0 |
| Nova 1200 | 1.2 μs | N/A | 2.5 |
| Nova 2 | 1.0 μs | 1.0 μs | 4.5 |
| Supernova (Core) | 0.8 μs | 1.6 μs | 7.0 |
| Nova 4 | 0.4 μs | 0.2 μs | ~10x (est.) |