Intel i960
The Intel i960 is a family of 32-bit reduced instruction set computing (RISC) microprocessors developed and manufactured by Intel Corporation, first introduced in 1988 as the company's initial foray into RISC architecture for embedded and high-performance applications.[1][2] Featuring a load-store design with pipelined execution, the i960 supported up to 250,000 transistors on a 1.5-micron process in its earliest iterations and evolved to include superscalar capabilities, allowing some variants to execute multiple instructions per clock cycle.[3][2] The architecture originated from Intel's earlier iAPX 432 project in the 1970s, a complex object-oriented design that influenced the i960's emphasis on protected memory and multitasking, though the i960 simplified this into a more conventional RISC framework supporting integer, floating-point, string, and load/store operations.[2] Variants included the basic KA core for general RISC processing, the KB with added floating-point support, the MC for memory-protected environments, and the XA for extended 33-bit addressing with object-oriented features, particularly in military applications.[2] Later superscalar models like the CA (1990) and CF achieved clock speeds up to 40 MHz and performance ratings of 66 million instructions per second (MIPS), making them suitable for demanding tasks.[3][1] The i960 found widespread adoption in embedded systems during the 1990s, powering devices such as Hewlett-Packard LaserJet printers, Sega Daytona arcade games, early GPS receivers, and video poker machines, while also serving in military systems like the F-22 Raptor and selected by the Joint Integrated Avionics Working Group (JIAWG) as the standard for military avionics interoperability.[3][2] Specialized variants, such as the i960 RP introduced in the mid-1990s, integrated peripherals like PCI bridges, DMA controllers, and memory management for intelligent I/O subsystems in servers and networking equipment, supporting up to 31 VAX MIPS and 256 MB of DRAM.[4] Despite its technical innovations, the i960 was eventually overshadowed by Intel's x86 dominance and competing RISC architectures, with production ceasing around 2007.[2]Development History
Origins and Design Goals
In the mid-1980s, Intel began exploring reduced instruction set computing (RISC) architectures as an alternative to its established complex instruction set computing (CISC) x86 line, driven by the growing popularity of RISC designs in academic and industry research. This shift was influenced by pioneering projects such as the Berkeley RISC I, detailed in a 1982 paper by David Patterson and colleagues, which emphasized simplified instructions and pipelining for higher performance, and the Stanford MIPS project, which developed a clean 32-bit RISC instruction set starting around 1981. Intel's move reflected broader industry trends toward RISC for embedded and high-performance applications, aiming to diversify beyond personal computing while leveraging lessons from its earlier iAPX 432 project, a complex object-oriented design from the late 1970s that ultimately underperformed commercially. The project began in 1984 as part of the Intel-Siemens BiiN collaboration for fault-tolerant systems, before evolving into Intel's independent RISC effort.[5][2][6] The i960 project, internally known as the 80960 during development, was led by key architects including Glenford Myers, who was recruited from IBM to oversee the architecture, and Fred Pollack, a superscalar specialist who served as the lead engineer. Many team members were drawn from the iAPX 432 group, bringing expertise in advanced features like capability-based protection, but the focus shifted to a more streamlined RISC approach for practicality. The design targeted high-performance embedded systems, such as controllers in appliances and avionics, as well as scientific computing environments requiring efficient real-time processing.[2] Core design goals included achieving 2-3 times the performance of the 80386 in relevant workloads, through innovations like deep pipelining and on-chip support for fault tolerance via error-correcting code (ECC) memory and redundant execution paths. The architecture was engineered for multiprocessing scalability, enabling symmetric multiprocessor configurations without excessive software overhead, and real-time operations that minimized operating system intervention for deterministic response times. These objectives positioned the i960 as a versatile platform for fault-tolerant systems in demanding environments.[2] Intel unveiled the i960 family, initially branded as the 80960, at the 1988 Microprocessor Forum, marking its entry into RISC processors and emphasizing embedded applications over direct competition with x86 desktops. The announcement highlighted the chips' RISC foundation for superior speed in control systems, such as microwave ovens and aircraft flight controls, signaling Intel's strategic expansion into non-PC markets.[7][2]Development Timeline and Releases
Development of the Intel i960 began in the mid-1980s as an internal project at Intel, initially under the codename P7, which aimed to create a high-performance RISC processor for embedded applications. By October 1985, the design reached tape-out, with prototypes entering manufacturing that month and first working silicon available in late 1985 or early 1986. Internal testing and refinement continued through 1987, focusing on validating the architecture's superscalar capabilities and object-oriented features for real-time systems.[8][9] In 1988, Intel announced the i960 family, with initial releases of the 80960KA and 80960KB models. The 80960MC followed in early 1989, operating at clock speeds of 10 to 20 MHz on a 1.5 μm process. This marked the commercial debut of the processor, targeted at military and embedded controller markets, including support for extended architecture variants like the XA. The 80960MC served as the foundational military-grade member, emphasizing reliability and a 33-bit memory addressing mode.[10][11] The 1990s saw significant expansions in the i960 lineup to address diverse embedded needs. In 1990, the i960 XA was introduced on a shrunk 1 μm process, enhancing object-oriented programming support and selected as a standard by the Joint Integrated Avionics Working Group. The superscalar i960 CA followed in 1989 on a 1.0 μm process, capable of executing two instructions per clock cycle. By 1995, the Jx series debuted on 0.35 μm, offering improved I/O integration, followed by higher-speed variants reaching 100 MHz in the late 1990s on processes down to 0.18 μm.[11][12][13] Key partnerships bolstered the i960's ecosystem for real-time and I/O applications. In the 1990s, Wind River Systems' VxWorks provided robust real-time operating system support for i960-based embedded systems. Additionally, in 1996, Intel co-developed the Intelligent I/O (I2O) standard, leveraging i960 processors like the RP variant as dedicated I/O controllers to offload tasks from host CPUs in networked environments.[14][4] Production evolved with advancing semiconductor processes, transitioning from 1.5 μm in 1988 to 1 μm by 1990, 0.8 μm in 1993, 0.35 μm in 1995, 0.25 μm in 1996, and ultimately 0.18 μm by the late 1990s, enabling higher frequencies and integration for specialized models.[2]Architecture
RISC Principles and Innovations
The Intel i960 architecture embodies core Reduced Instruction Set Computing (RISC) principles by adopting a load/store model, where computational operations are confined to registers, and memory access is restricted to dedicated load and store instructions. This separation enhances pipeline efficiency and simplifies hardware design, allowing for faster execution cycles compared to architectures that permit direct memory operands in arithmetic instructions. All instructions are fixed at 32 bits and word-aligned, promoting uniform decoding and enabling the processor to fetch and process instructions predictably without the overhead of variable-length parsing.[15][16][17] The i960's instruction set is highly orthogonal, meaning operations can be applied uniformly across registers and data types without dependencies on specific register roles or modes, which minimizes decoding complexity and maximizes code portability across implementations. At the heart of this design is a 32-register file comprising 16 global registers (g0–g15) that persist across procedure calls and 16 local registers (r0–r15) allocated per procedure for stack-based management. Dedicated registers include r0 (previous frame pointer), r1 (stack pointer), and r2 (return instruction pointer), streamlining procedure linkage and reducing the need for explicit stack manipulations in common code patterns.[15][18][17] In contrast to contemporary Complex Instruction Set Computing (CISC) designs like the x86, which rely on variable-length instructions that complicate prefetching and decoding hardware, the i960's fixed-length format avoids such pitfalls, enabling simpler, more predictable instruction scheduling and higher clock speeds in embedded environments. Key innovations include on-chip fault detection mechanisms, such as parity checking on data buses and critical paths, which generate synchronous faults like MACHINE.PARITY_ERROR to ensure reliability in safety-critical applications; this is enabled via configurable bits in control registers. Additionally, the architecture supports atomic operations for multiprocessing, with instructions likeatadd and atmod providing indivisible read-modify-write sequences within 16-byte memory blocks, synchronized via a LOCK signal to maintain data coherency across multiple processors without requiring external arbitration.[2][15][17][18]
Instruction Set and Formats
The Intel i960 instruction set architecture (ISA) is a load-store design emphasizing 32-bit operations, with approximately 100 instructions in total that support efficient integer and floating-point processing.[18] The ISA organizes instructions into three primary formats to balance code density and functionality: single-word formats for memory access operations, dual-word formats for register-based computations, and co-processor formats for specialized extensions like floating-point units.[18] Single-word instructions are 32 bits long and aligned on 32-bit boundaries, typically handling straightforward memory loads, stores, or branches, such as themov (move) or b (branch) operations.[18] Dual-word instructions span two 32-bit words, enabling more complex register operations like arithmetic or extended addressing in calls, exemplified by addi (add immediate) or call (procedure call).[18] Co-processor instructions, often integrated in later variants, facilitate interactions with floating-point or other accelerators, using formats like control register operations (CTRL) or co-processor branches (COBR).[18]
Addressing modes in the i960 ISA prioritize flexibility for RISC-style efficiency while supporting common access patterns, including register direct, register indirect with displacement, and immediate values.[18] Register direct mode accesses operands directly from one of the 32 general-purpose registers without additional computation, ideal for fast ALU operations.[18] Register indirect with displacement adds a signed 12-bit offset to a base register for memory referencing, as in load/store instructions like ld (load) or st (store). Indexed modes add a scaled index register (scale factors of 1, 2, 4, 8, or 16) plus optional displacement.[18] Immediate values embed constants directly in the instruction word, limited to short literals for operations such as addi or conditional branches like be (branch if equal).[18] These modes extend to indexed variants and instruction-pointer-relative addressing for branches, ensuring compact code without compromising performance.[18]
The core operation categories encompass integer arithmetic and logic unit (ALU) instructions, load/store operations, and control flow mechanisms, with floating-point support added in variants featuring an integrated FPU.[18] Integer ALU instructions perform 32-bit operations including addition (add), subtraction (sub), multiplication (mul), division (div), and logical functions (AND, OR, XOR), often with immediate or register operands for tasks like muli (multiply immediate).[18] Load/store instructions handle data movement in byte (8-bit), half-word (16-bit), word (32-bit), or longer formats, such as ldl (load locked) for synchronization or stq (store quadword) for 128-bit transfers, maintaining a strict separation between computation and memory access.[18] Control flow instructions include unconditional branches (b), conditional variants (bl for branch if less), and procedure calls (call, bal for branch and link), with support for prediction hints in some formats to optimize execution paths.[18]
Floating-point support, introduced in second-generation models like the 80960KB, complies with the IEEE 754 standard for single-precision (32-bit) and double-precision (64-bit) arithmetic, with optional extended precision (80-bit).[18] These instructions, such as addr (add real), mulr (multiply real), and divr (divide real), operate on dedicated floating-point registers and include transcendental functions like sinr (sine real) for scientific computing.[18] Co-processor formats enable these operations to integrate seamlessly with the integer pipeline, ensuring the i960's suitability for embedded and real-time applications requiring precise numerical processing.[18]
Pipeline and Execution Model
The Intel i960 architecture features a classic five-stage pipeline designed to overlap instruction execution for improved throughput: the fetch stage retrieves instructions from memory or cache, the decode stage interprets opcodes and operands, the execute stage performs arithmetic and logical operations, the memory access stage handles load and store operations, and the write-back stage commits results to the register file. This pipelined approach enables sustained instruction processing at one instruction per clock cycle in base models, with register scoreboarding allowing execution to proceed even while data dependencies are resolved.[15][18] Separate execution units support parallel processing within the pipeline, including an integer execution unit (EU) for arithmetic and logical operations on 32-bit integers and ordinals, a multiply/divide unit (MDU) for extended integer multiplications/divisions and floating-point operations in supported variants, and a system control unit managing privileges, stacks, and procedure calls. The EU handles most single-cycle operations, while the MDU operates in parallel for multi-cycle tasks, and the control unit oversees mode switches and fault resolution. In later variants like the i960 CA and CF, these units integrate with additional components such as an address generation unit (AGU) and bus control unit (BCU) to facilitate concurrent address calculation and memory transactions.[15][19][18] Select superscalar variants, such as the i960 CA and CF, introduce dual-issue capability, allowing the dispatch of up to two instructions per clock cycle—typically one integer operation from the EU and one load/store from the memory pipeline—in a sustained manner, with peaks of three issues in burst scenarios. This parallelism relies on an instruction scheduler that groups compatible instructions (e.g., REG for register operations, MEM for memory accesses, and CTRL for control flow) and uses scoreboarding to track resource availability, enabling out-of-order completion while maintaining in-order retirement. Earlier models like the i960 KB lack this superscalar dispatch, relying instead on scalar pipelining with overlapped execution.[15][19] Branch handling incorporates a static prediction scheme, where backward branches are predicted as taken and forward branches as not taken, augmented by a programmer-specified T bit (0 for likely true, 1 for likely false) in conditional instructions to guide prefetching along the anticipated path. This mechanism, combined with delay slots that allow 1-2 subsequent instructions to execute regardless of branch outcome, minimizes pipeline stalls; correct predictions enable zero-cycle branch resolution via lookahead prefetching of up to four instructions from the on-chip cache. In non-superscalar variants like the i960 KB, branch prediction is absent, with reliance on a single delay slot and pipeline overlap for zero-cycle execution in optimal cases.[15][18] The exception model ensures precise interrupts, where faults such as arithmetic errors, page faults, or invalid opcodes trap execution at the faulting instruction without disrupting prior pipeline results. An on-chip fault handler, invoked via an implicit procedure call, saves processor state to a dedicated interrupt stack, records fault details (type, subtype, and instruction address) in a fault table, and dispatches to a user-defined handler from the system procedure table. Resumption occurs by restoring state and returning to the faulting point or an alternate address, supporting both user and supervisor modes with stack separation for security. Floating-point exceptions receive dedicated handling through the MDU, integrating seamlessly with the general model.[15][18]Memory Management and Protection
The Intel i960 architecture employs a flat 32-bit virtual address space, spanning 4 gigabytes and organized as a linear, byte-addressable memory model without segmentation.[18] This design facilitates efficient addressing for embedded applications, with support for demand-paged virtual memory using 4 KB pages managed by an integrated or external memory management unit (MMU).[20] The MMU translates virtual addresses to physical addresses, enabling multitasking environments where multiple tasks can share the address space while maintaining isolation. In variants like the 80960MC and 80960XA, the address space is divided into regions—typically four 1 GB regions—with the uppermost region reserved for system-wide shared memory accessible to all tasks.[20][11] Address translation is accelerated by an on-chip translation lookaside buffer (TLB) integrated with the MMU, which caches recent virtual-to-physical mappings to reduce latency for repeated accesses.[20] The TLB operates in conjunction with page tables that define page attributes, including presence bits for demand paging and protection fields to enforce access rules. Page faults trigger precise exceptions, allowing the operating system to handle missing pages or violations without corrupting the processor state. This mechanism supports large virtual address spaces exceeding physical memory limits, ideal for real-time systems requiring dynamic memory allocation.[11] Protection in the i960 is implemented through two privilege modes—supervisor mode (highest privilege) and user mode (lowest privilege). Transitions between modes are controlled via explicit calls, such as system procedure invocations, which validate caller privileges before granting access to sensitive resources like control registers or kernel stacks. Each page descriptor includes a 2-bit rights field specifying access permissions: no access (for user mode), read-only, read-write, or full access, with supervisor mode overriding user restrictions on certain pages.[20] This mode-based model, combined with capability-like mechanisms for object-oriented protection in extended architectures, enables sandboxing of processes by restricting memory access based on privilege levels and preventing unauthorized interprocess interference. Protection faults, such as length violations or privilege escalations, generate precise interrupts to maintain system integrity in multiprocessor configurations.[2][11] The cache hierarchy in i960 processors features on-chip split instruction and data caches, with sizes varying across variants to balance performance and die area—typically ranging from 512 bytes for early instruction-only caches to 4–16 KB split configurations in later models like the Jx and Hx series.[21] Instruction caches are direct-mapped or set-associative, prefetching aligned blocks (e.g., 16 bytes) to exploit spatial locality, while data caches employ a write-through policy with write-allocate on misses to ensure data consistency in shared-memory environments.[15] Cache operations can be configured via control registers for locking critical lines or invalidation, and coherence is maintained through bus snooping protocols in multiprocessor setups, though external cache controllers are supported for larger off-chip hierarchies.[21] The processor interfaces with memory via a 32-bit multiplexed address/data bus, operating synchronously and supporting burst transfers up to 16 bytes for efficient block moves.[18] This bus design, often termed the L-Bus, includes control signals for atomic locks and pipelining, achieving peak throughputs of 66–132 MB/s depending on clock speed and configuration. External memory controllers can extend the hierarchy, with programmable wait states per region to accommodate varying DRAM timings. For direct memory access (DMA), integrated controllers in advanced variants provide up to four channels, enabling I/O devices to transfer data independently of the CPU core using modes like block, fly-by, or chained operations.[15] These channels use dedicated queues and synchronization primitives to avoid bus contention, supporting transfers up to 4 GB while preserving cache coherence through software flushes.[15]Processor Variants
First-Generation Models
The first-generation models of the Intel i960 processor family, launched between 1988 and 1991, established the architecture's role in high-performance embedded computing, emphasizing reliability, multitasking, and integration for real-time applications. These included the 80960MC as the foundational variant, followed by the 80960XA for enhanced signal processing and the 80960KA/KB for advanced multiprocessing support. Fabricated primarily on a 1.5 μm process, the models featured 132-pin PGA or PQFP packaging and power dissipation typically between 2.5 and 3.5 W, enabling efficient operation in constrained environments. Commercial variants such as the 80960SB and SA offered lower-power alternatives for non-military embedded systems.[19] The 80960MC, introduced in 1988, formed the core of the first generation as a military-grade embedded processor operating at 10–25 MHz, with a 512-byte on-chip instruction cache, integrated floating-point unit (FPU), memory management unit (MMU), and interrupt controller to support fault-tolerant and multiprocessor configurations.[22] It delivered sustained performance exceeding 6 MIPS at 16 MHz and up to 7.5 MIPS at 20 MHz in burst modes, using a 1.5 μm process and consuming approximately 2.5 W.[19] Designed for real-time embedded control, the 80960MC targeted avionics, industrial automation, and data communications, where its load/store RISC design and debugging features facilitated high-reliability systems.[22] Released in 1990, the 80960XA built on the 80960MC as a superset optimized for signal processing, incorporating an extended arithmetic unit alongside the existing FPU, 512-byte instruction cache, and on-chip MMU at clock speeds of 16–33 MHz.[11] Implemented in a 1.5 μm process within a 132-pin PGA or 164-pin CQFP package, it drew up to 2.6 W at 25 MHz while adhering to military standards like the JIAWG 32-bit ISA.[11] The model's focus on multitasking with automatic task dispatching and a 33-bit tag for data security suited high-reliability environments, including military avionics, industrial automation, and telecommunications.[11] The 80960KA and pin-compatible 80960KB, introduced in 1991, provided high-end capabilities for burst-oriented and multiprocessing systems, both running at 16–33 MHz with a 512-byte instruction cache and built-in interrupt controller on a 1.5 μm process in 132-lead PGA or PQFP packages.[23] The 80960KA supported up to 9.4 MIPS sustained and 25 MIPS in bursts without an on-chip FPU, relying on software libraries for floating-point operations, while the 80960KB integrated an IEEE 754-compliant FPU achieving 13.6 MWhetstone/s, with power consumption approximately 2.1 W at 25 MHz.[19] These variants emphasized address pipelining, burst transfers, and compatibility with DRAM subsystems, targeting embedded applications in non-impact printers, I/O control, networking, specialty instrumentation, and industrial systems.[23] Across these models, the i960's RISC innovations—such as multiple execution units and virtual memory protection—enabled early adoption in avionics and industrial automation, where fault tolerance and low-latency interrupts were critical.[19]Second-Generation Models
The second-generation Intel 80960 processors, introduced in the early to mid-1990s, enhanced the architecture's embedded focus through greater on-chip integration of core and peripherals, enabling more efficient system designs compared to the first-generation models' external dependencies.[19] These models emphasized superscalar execution for higher throughput and improved real-time performance, with clock speeds scaling from 16 MHz to over 40 MHz in standard variants.[24] The 80960CA and 80960CF, launched around 1993, represented the initial advancements in this generation by integrating a superscalar RISC core with essential peripherals directly on-chip, reducing board space and power draw for embedded applications.[19] Operating at clock speeds of 16–33 MHz for the CA and up to 40 MHz for the CF (with later CF variants reaching effective 66 MIPS performance), they included four DMA channels supporting up to 59 Mbytes/s fly-by transfers and a high-speed interrupt controller handling up to 248 external interrupts across 32 priorities.[24] The CF added an on-chip floating-point unit and larger caches (4 KB instruction and 1 KB data), doubling peak performance over the CA's 1 KB instruction cache and 1 KB data RAM configuration.[24] Fabricated on a 1.0 μm process, these processors were packaged in options like 196-lead PQFP and consumed 1–3 W at typical operating frequencies, with context switching latency around 750 ns.[19] The 80960MX, introduced in 1994, targeted low-power mobile and portable embedded systems with a 3.3 V design and reduced I/O pin count to minimize interface complexity.[25] Clocked at 16–40 MHz, it maintained code compatibility with other 80960 family members while optimizing for multiprocessing and memory management, drawing under 2 W to support battery-constrained environments.[26] Built on a sub-micron process similar to contemporaries, the MX used packages like 132-lead PQFP, prioritizing efficiency over raw speed for applications requiring extended operation without frequent recharging.[25] The 80960Jx series, released in 1995, further refined real-time capabilities with deterministic response mechanisms and enhanced interrupt handling, making it suitable for time-critical embedded tasks.[27] Variants such as JA, JF, JD, JC, JS, and JT operated at 25–100 MHz core speeds (with bus clocks up to 33 MHz and multipliers up to 3x), featuring low-latency interrupts across 31 priorities and up to 240 vectors, plus two on-chip 32-bit timers for precise system timing.[19] These processors, fabricated on 0.8 μm processes, supported 3.3 V operation with halt modes reducing power by up to 90%, consuming 1–3 W, and were available in packages including 196-lead PQFP and 132-lead PGA.[27] The Jx innovations, including JTAG boundary scan and larger caches (up to 4 KB instruction in JF models), improved compatibility with real-time operating systems like VxWorks through efficient multitasking and fault tolerance.[19]Third-Generation and Specialized Models
The third-generation Intel 80960 processors, introduced in the late 1990s, represented the pinnacle of the architecture's evolution toward higher performance in embedded applications, building on the superscalar foundations of earlier models like the 80960CF. The 80960HA, HD, and HT variants, released between 1996 and 1998, targeted demanding environments such as graphics processing, real-time simulations, and high-end industrial controls. These processors operated at clock speeds ranging from 25 MHz to 80 MHz, with the HD featuring internal 2x clock multiplication and the HT employing 3x multiplication to boost core performance relative to the external bus. They incorporated larger on-chip caches compared to prior generations, including a 16 KB four-way set-associative instruction cache and an 8 KB four-way set-associative data cache, alongside 2 KB of data RAM, enabling sustained execution of two instructions per clock cycle and peak rates up to three instructions per cycle through parallel decoding and execution units. Fabricated on a 0.35 μm CMOS process with 3.3 V operation and 5 V tolerant inputs, these chips were housed in 168-pin PGA or 208-pin PQFP packages, with power consumption reaching up to 1.58 A at 80 MHz under active load.[28][29] The 80960VH, announced in 1997 and entering production around 1999, extended the family into PCI-centric embedded systems, providing an integrated solution for high-speed I/O interfaces in networking and multimedia peripherals. Operating at an internal core clock of 100 MHz with a 33 MHz PCI bus, it featured a 16 KB two-way set-associative instruction cache, a 4 KB direct-mapped data cache, and 1 KB of internal data RAM, supporting burst transactions and compliance with PCI Local Bus Specification Revision 2.2. Built on an advanced 0.35 μm CMOS process with 3.3 V supply and 5 V tolerant I/O, the 80960VH used a 324-lead PBGA package and drew up to 720 mA in high-performance modes. Its design emphasized low-latency PCI integration for embedded controllers, including an on-chip memory management unit and support for DRAM and SRAM interfaces, making it suitable for applications requiring seamless host-peripheral communication.[30] The 80960Rx series, comprising the RP and RD models released in 1998, marked Intel's final major push for the i960 in specialized I/O roles, particularly as intelligent input/output (I2O) processors for storage and server subsystems. The 80960RP ran at 33 MHz, while the clock-doubled 80960RD reached 66 MHz, integrating a PCI-to-PCI bridge compliant with Revision 2.1, a three-channel DMA controller, and support for up to 256 MB of DRAM via an on-chip memory controller. These variants included 4 KB instruction cache, 2 KB data cache, and 1 KB data RAM, with features like an I2C interface for system management and a messaging unit to facilitate I2O protocol operations, enabling efficient peer-to-peer data transfers in RAID arrays and fiber-channel environments. Produced on a 0.35 μm process with 3.3 V operation, they were packaged in a 352-lead PBGA and consumed up to 1.3 A during active operation. The I2O integration allowed these processors to offload I/O tasks from host CPUs, supporting split-driver models for enhanced scalability in enterprise storage controllers.[31][32]Specifications and Comparisons
Key Specifications Table
| Model | Clock Speed (MHz) | Process (μm) | Cache Sizes (I/D KB) | Transistors (millions) | Power (W) | Package Type |
|---|---|---|---|---|---|---|
| i960MC | 20–25 | 1.5 | 0.5/0 | 0.25 | N/A | 132-pin PGA https://micro.magnet.fsu.edu/optics/olympusmicd/galleries/chips/intel960a.html |
| i960CA | 16–33 | 0.8 | 1/0 | 0.6 | N/A | 168-pin PGA, 196-pin PQFP https://datasheets.chipdb.org/Intel/80960/PRODBREF/272211_3.PDF https://micro.magnet.fsu.edu/optics/olympusmicd/galleries/chips/intel960a.html |
| i960CF | 16–40 | 0.8 | 4/1 | 0.9 | N/A | 168-pin PGA, 196-pin PQFP https://datasheets.chipdb.org/Intel/80960/PRODBREF/272211_3.PDF https://micro.magnet.fsu.edu/optics/olympusmicd/galleries/chips/intel960a.html https://www.cecs.uci.edu/~papers/mpr/MPR/ARTICLES/071703.pdf |
| i960JT | 33–100 | 0.35 | 16/4 | N/A | N/A | Mini-PBGA, PQFP https://datasheets.chipdb.org/Intel/80960/OVERVIEW/27250604.PDF |
| i960HT | 60–75 | 0.35 | 16/8 | N/A | N/A | PGA, CQFP https://datasheets.chipdb.org/Intel/80960/PRODBREF/27259003.PDF |
| i960RD | 66 | 0.25 | 4/2 | N/A | 4.3 (max) | 352-lead BGA http://www.bitsavers.org/components/intel/i960/273001-003_i960RX_Data_Sheet_200108.PDF |