Editing Intel i860

{{distinguish|text=[[List of Intel chipsets#Pentium 4 chipsets|Intel 860 chipset]]}}
{{short description|Microprocessor design by Intel}}
{{Infobox CPU architecture
| name       = Intel i860
| designer   = [[Intel]]
| bits       = 32/64-bit
| introduced = 1989
| design     = [[RISC]], [[VLIW]]
| type       = [[Load–store]]
| encoding   = Fixed
| branching  = Compare and branch
| endianness = [[Bi-endian|Bi]] (switchable)
| page size  = 4 KB
| extensions = 64-bit graphics unit
| gpr        = 32 32-bit
| fpr        = 32 32-bit (16 64-bit)
}}

The '''Intel i860''' (also known as '''80860''') is a [[RISC]] [[microprocessor]] design introduced by [[Intel]] in 1989. It is one of Intel's first attempts at an entirely new, high-end [[instruction set architecture]] since the failed [[Intel iAPX 432]] from the beginning of the 1980s. It was the world's first million-transistor chip.<ref name=":0">{{Cite web |last=Perry |first=Tekla |date=2022-07-02 |title=The First Million-Transistor Chip: the Engineers' Story |url=https://spectrum.ieee.org/intel-i860 |url-status=live |archive-url=https://web.archive.org/web/20220705003416/https://spectrum.ieee.org/intel-i860 |archive-date=2022-07-05 |access-date=2022-07-05 |website=[[IEEE Spectrum]] |language=en}}</ref> It was released with considerable fanfare, slightly obscuring the earlier [[Intel i960]], which was successful in some niches of [[embedded system]]s. The i860 never achieved commercial success and the project was terminated in the mid-1990s.

==Implementations==
{{Infobox CPU
| name        = i860 XR
| image       = KL Intel i860XR.jpg
| caption     = Intel i860 XR microprocessor (33 MHz edition)
| produced-start = 1989
| produced-end = mid-1990s
| slowest     = 25  | slow-unit     = MHz
| fastest     = 40  | fast-unit     = MHz
| manuf1      = Intel
| arch        = Intel i860
| numcores = 1
| l1cache        = 4 KB (I) + 8 KB (D)
| successor      = i860 XP
}}
[[File:Intel 80860XR die.JPG|thumb|[[Die (integrated circuit)|Die]] of Intel i860 XR.]]
{{Infobox CPU
| name        = i860 XP
| image       = Intel i860 XP A80860XP-50 L4190197 top.jpg
| caption     = Intel i860 microprocessor (50 MHz edition)
| produced-start = 1991
| produced-end = mid-1990s
| slowest     = 40  | slow-unit     = MHz
| fastest     = 50  | fast-unit     = MHz
| manuf1      = Intel
| arch        = Intel i860
| transistors = 1 million<ref>Lewnes, Ann, "The Intel386 Architecture Here to Stay", Intel Corporation, Microcomputer Solutions, July/August 1989, page 2</ref>
| numcores = 1
| l1cache        = 16+16 KB
| predecessor    = i860 XR
}}
[[File:Intel 80860XP die.JPG|thumb|[[Die (integrated circuit)|Die]] of Intel i860 XP.]]

The first implementation of the i860 architecture is the i860 '''XR''' microprocessor (code-named '''N10'''), which ran at 25, 33, or 40&nbsp;MHz.  The second-generation i860 '''XP''' microprocessor (code named '''N11''') added 4 Mbyte pages, larger on-chip caches, second level cache support, faster buses, and hardware support for bus snooping to provide [[cache coherence]] in [[multiprocessor]] systems. A process shrink for the XP from 1 μm to 0.8 μm using the [[CHMOS]] V process increased the clock to 40 and 50&nbsp;MHz.<ref>{{Cite web |url=http://www.hotchips.org/wp-content/uploads/hc_archives/hc03/2_Mon/HC3.S3/HC3.3.2.pdf |title=The i860 XP - Second Generation of the i860. |access-date=2015-02-22 |archive-date=2018-08-20 |archive-url=https://web.archive.org/web/20180820124131/http://www.hotchips.org/wp-content/uploads/hc_archives/hc03/2_Mon/HC3.S3/HC3.3.2.pdf |url-status=dead }}</ref> Both microprocessors supported the same instruction set for application programs.

==Technical features==
The i860 combined a number of features that were unique at the time, most notably its [[very long instruction word]] (VLIW) architecture and powerful support for high-speed floating-point operations.<ref>{{cite journal
 |last1=Kohn
 |first1=Les
 |last2=Margulis
 |first2=N.
 |title=Introducing the Intel i860 64-Bit Microprocessor
 |pages=15–30
 |journal=IEEE Micro
 |publisher=IEEE Computer Society
 |date=August 1989
 |volume=9
 |issue=4
 |doi=10.1109/40.31485
 |s2cid=21922034
 }}</ref> The design uses two classes of instructions: "core" instructions which use a [[32-bit]] [[Arithmetic logic unit|ALU]], and "floating-point or graphics" instructions which operate on a floating-point adder, a floating-point multiplier, or a 64-bit integer graphics unit. The system had separate [[Instruction pipelining|pipelines]] for the ALU, floating-point adder, floating-point multiplier, and graphics unit. It can [[Instruction cycle|fetch and decode]] one "core" instruction and one "floating-point or graphics" instruction per clock. When using dual-operation floating-point instructions (which transfer values between subsequent dual-operation instructions), it is able to execute up to three operations (one ALU, one floating-point multiply, and one floating-point add-or-subtract) per clock.<ref name=":0" /><ref name=":1">{{Cite book |url=http://www.bitsavers.org/components/intel/i860/240329-002_i860_64-Bit_Microprocessor_Programmers_Reference_Feb89.pdf |title=i860 64-bit Microprocessor Programmer's Reference Manual |publisher=[[Intel]] |year=1989 |location=Santa Clara, CA, USA |language=en |archive-url=https://web.archive.org/web/20220223123909/http://bitsavers.org/components/intel/i860/240329-002_i860_64-Bit_Microprocessor_Programmers_Reference_Feb89.pdf |archive-date=2022-02-23 |url-status=live}}</ref>

All of the data buses were at least 64 bits wide. The internal memory bus to the cache, for instance, was 128 bits wide.

The "core" class instructions use thirty-two 32-bit integer registers. But the "floating-point or graphics" instructions use a register file that can be accessed by the floating point units as either thirty-two 32-bit, sixteen 64-bit, or eight 128-bit floating-point registers, or that can be accessed by the graphics unit as sixteen 64-bit integer registers.

The "core" unit is responsible for fetching instructions, and in the normal "single-instruction" mode can fetch one 32-bit "core" or one 32-bit "floating point or graphics" instruction per cycle. But when executing in dual-instruction mode, the instruction cache is accessed as VLIW instructions consisting of a 32-bit "core" instruction paired with a 32-bit "floating-point or graphics" instruction, simultaneously fetched together over a 64-bit bus.<ref name=":1" />

Intel referred to the design as the "i860 64-Bit Microprocessor".<ref>{{cite journal
 |last1=Grimes
 |first1=Jack 
 |last2=Kohn
 |first2=L. 
 |last3=Bharadhwaj
 |first3=R.
 |title=The Intel i860 64-Bit Processor: A General-Purpose CPU with 3D Graphics Capabilities
 |pages=85–94
 |journal=IEEE Computer Graphics and Applications
 |publisher=IEEE Computer Society
 |date=July 1989
 |doi=10.1109/38.31467
 |volume=9
 |issue=4
 |s2cid=38831149 
 }}</ref>

Intel i860 instructions acted on data sizes from 8-bit through 128-bit.<ref>{{cite web
 |title=The Chip Collection - i860 Microprocessor - Smithsonian Institution
 |url=http://smithsonianchips.si.edu/intel/i860.htm
 |website=Smithsonian Institution
 }}</ref>

The graphics supports [[SIMD]]-like instructions in addition to basic 64-bit integer math. For instance, its 64-bit integer datapath can represent multiple pixels together as either 8-bit pixels, 16-bit pixels, or 32-bit pixels.<ref name=":1" /> Experience with the i860 influenced the [[MMX (instruction set)|MMX]] functionality later added to Intel's [[Pentium]] processors.

The pipelines into the functional units are program-accessible ([[VLIW]]), requiring the [[compiler]]s to order instructions carefully in the [[object code]] to keep the pipelines filled. In traditional architectures these duties were handled at runtime by a scheduler on the CPU itself, but the complexity of these systems limited their application in early RISC designs. The i860 was an attempt to avoid this entirely by moving this duty off-chip into the compiler. This allowed the i860 to devote more room to functional units, improving performance. As a result of its architecture, the i860 could run certain graphics and floating-point algorithms with exceptionally high speed, but its performance in general-purpose applications suffered and it was difficult to program efficiently (see below).

The i860 has both non-delayed and delayed branch instructions. When delayed branches are taken, the following instruction will be executed prior to transferring control to the branch target instruction. It means the i860 has a single branch delay slot.<ref>{{Cite web |url=http://www.bitsavers.org/components/intel/i860/240329-002_i860_64-Bit_Microprocessor_Programmers_Reference_Feb89.pdf#page=70 |title=i860™ 64-bit Microprocessor Programmer's Reference Manual |page=70(5-11) |accessdate=2023-12-21}}</ref>

==Performance==
On paper, performance was impressive for a single-chip solution; however, real-world performance was anything but. One problem, perhaps unrecognized at the time, was that runtime code paths are difficult to predict, meaning that it becomes exceedingly difficult to order instructions properly at [[compile time]]. For instance, an instruction to add two numbers will take considerably longer if those numbers are not in the cache, yet there is no way for the programmer to know if they are or not. If an incorrect guess is made, the entire pipeline will stall, waiting for the data. The entire i860 design was premised on the compiler writing instructions that executed this task efficiently, which proved almost impossible in practice. While theoretically capable of peaking at about 60-80 MFLOPS for both [[single precision]] and [[double precision]] for the XP versions,<ref>{{cite web | title = Intel i860 : 64-Bit Microprocessor | url = http://www.microprocessor.sscc.ru/i860.html | archive-url   = https://web.archive.org/web/20090623025958/http://www.microprocessor.sscc.ru/i860.html | archive-date  = 2009-06-23 | access-date = 2013-09-27 | author = Oleg Yu. Repin, Alexei S. Pylkin | year = 2000 | publisher = sscc.ru, ICMMG }}</ref> manually written [[Assembly language#Assembler|assembler code]] managed to get up to only about 40 MFLOPS, and most compilers had difficulty getting even 10 MFLOPs.<ref>{{cite report
 | first1 = D.H.
 | last1 = Bailey
 | first2 = E.
 | last2 = Barszcz
 | first3 = R.A.
 | last3 = Fatoohi
 | first4 = H.D.
 | last4 = Simon
 | first5 = S.
 | last5 = Weeratunga
 | title = Performance Results on the Intel Touchstone Gamma Prototype
 | publisher = NASA Ames Research Center
 | date = 1990
 | url = https://www.nas.nasa.gov/assets/pdf/techreports/1990/rnr-90-007.pdf
 | access-date = 2016-07-10
 | archive-date = 2016-12-21
 | archive-url = https://web.archive.org/web/20161221195710/https://www.nas.nasa.gov/assets/pdf/techreports/1990/rnr-90-007.pdf
 | url-status = dead
 }}</ref> The later [[IA-64|Itanium]] architecture, also a VLIW design, suffered again from the problem of compilers incapable of delivering sufficiently optimized code.

Another serious problem was the lack of any solution to handle [[context switch]]ing quickly. The i860 had several pipelines (for the ALU and FPU parts) and an interrupt could spill them and require them all to be re-loaded. This took 62 cycles in the best case, and almost 2000 cycles in the worst. The latter is 1/20000th of a second at 40&nbsp;MHz (50 microseconds), an eternity for a CPU. This largely eliminated the i860 as a general purpose CPU.

==Demise==
As the compilers improved, the general performance of the i860 did likewise, but by then most other RISC designs had already passed the i860 in performance.

In the late 1990s, Intel replaced their entire RISC line with [[ARM architecture family|ARM]]-based designs, known as the [[XScale]]. Confusingly, the 860 number has since been re-used for a motherboard control chipset for Intel [[Xeon]] (high-end [[Pentium]]) systems and a model of the Core i7.

[[Andy Grove]] suggested that the i860's failure in the marketplace was due to Intel being stretched too thin:
{{quote|text = We now had two very powerful chips that we were introducing at just about the same time: the 486, largely based on CISC technology and compatible with all the PC software, and the i860, based on RISC technology, which was very fast but compatible with nothing. We didn't know what to do. So we introduced both, figuring we'd let the marketplace decide. ... our equivocation caused our customers to wonder what Intel really stood for, the 486 or i860?|author=[[Andy Grove]]|source=
<ref>{{cite web |url=http://www.geek.com/intels-486-cpu-turns-15/ |title=Intel's 486 CPU turns 15 <!-- Bot generated title --> |date=3 June 2004 |first=Sander |last=Olson |website=Geek.com |archive-url=https://web.archive.org/web/20080525110753/http://www.geek.com/intels-486-cpu-turns-15/ |archive-date=2008-05-25 }}</ref>}}

==Applications==
[[Image:Paragon Card.jpg|300px|thumb|right|Three i860 XP-50 CPUs on a circuit board from Intel's [[Intel Paragon|Paragon XP/S supercomputer]]]]

At first, the i860 was only used in a small number of [[supercomputer]]s such as the [[Intel iPSC/860]]. Intel later marketed the i860 as a workstation microprocessor for a time, where it competed with microprocessors based on the [[MIPS architecture|MIPS]] and [[SPARC]] architectures, among others. The [[Oki Electric]] OKI Station 7300/30<ref>{{cite web
 |title=Oki Electric OKI Station 7300/30-Computer Museum
 |url=http://museum.ipsj.or.jp/en/computer/work/0029.html
 }}</ref> and [[Stardent]] Vistra 800<ref>{{cite web
 |title=Intel i860 - From Here to There
 |url=http://blog.garritys.org/2010/04/intel-i860.html
 |year=2010
}}</ref> [[Unix]] workstations were based on a 40&nbsp;MHz i860 XR running [[UNIX System V]]/i860.<ref>{{cite web
 |title=KUBOTA Computer/Stardent AVSstation Titan Vistra 800
 |url=http://computer-zoo.org/vistra/
 |access-date=2014-05-14
 |archive-url=https://web.archive.org/web/20140514150713/http://computer-zoo.org/vistra/
 |archive-date=2014-05-14
 |url-status=dead
 }}</ref>  The [[Hauppauge Computer Works|Hauppauge]] 4860<ref>{{cite web
 |title=GeekDot - Hauppauge 4860
 |date=20 March 2008
|url=http://www.geekdot.com/hauppauge-4860.html
}}</ref> and [[Olivetti]] CP486<ref>{{cite web
 |title=GeekDot - Olivetti CP486
 |date=16 August 2011
|url=http://www.geekdot.com/olivetti-cp486.html
}}</ref> featured an [[Intel 80486]] and i860 on the same motherboard.  Microsoft initially developed what was to become [[Windows NT]] on internally designed i860XR-based workstations (codenamed ''Dazzle''), only porting NT to the [[MIPS architecture|MIPS]] ([[Jazz (computer)|Microsoft Jazz]]), [[Intel 80386]] and other processors later. Some claim the NT designation was a reference to the "N-Ten" codename of the i860XR.<ref name="thurrott-roadtogold">{{cite web
 |url          = http://winsupersite.com/article/windows-server/windows-server-2003-the-road-to-gold-part-one-the-early-years-127432
 |title        = Windows Server 2003: The Road To Gold
 |date         = 2003-01-24
 |first        = Paul
 |last         = Thurrott
 |work         = Win super site
 |access-date   = 2013-09-02
 |archive-url  = https://web.archive.org/web/20110720042038/http://www.winsupersite.com/article/windows-server/windows-server-2003-the-road-to-gold-part-one-the-early-years-127432
 |archive-date = 2011-07-20
 |url-status   = dead
}}</ref>

The i860 also saw some use in the [[workstation]] world as a graphics accelerator. It was used, for instance, in the [[NeXTdimension]], where it ran a cut-down version of the [[Mach kernel]] running a complete [[PostScript]] stack. However, the [[PostScript]] part of the project was never finished so it ended up just moving color pixels around. In this role, the i860 design worked considerably better, as the core program could be loaded into the cache and made entirely "predictable", allowing the compilers to get the ordering right. The NeXTdimension could produce 32-bit graphics faster than the main NeXTcube's [[Motorola 68030]] could produce 2-bit graphics.

[[Truevision]] produced an i860-based accelerator board intended for use with their Targa and Vista framebuffer cards. [[Pixar]] produced a custom version of [[Pixar RenderMan (software)|RenderMan]] to run on the card that ran approximately four times faster than the 386 host. Another example was [[Silicon Graphics|SGI]]'s [[RealityEngine]], which used a number of i860XP processors in its geometry engine. This sort of use slowly disappeared as well, as more general-purpose CPUs started to match the i860's performance, and as Intel turned its focus to [[Pentium]] processors for general-purpose computing.

[[Mercury Computer Systems]] used the i860 in their [[multicomputer]]. From 2 to 360 compute nodes would reside in a [[circuit switched]] [[fat tree]] network, with each node having local memory that could be mapped by any other node. Each node in this heterogeneous system could be an i860, a [[PowerPC]], or a group of three [[Super Harvard Architecture Single-Chip Computer|SHARC]] DSPs. Good performance was obtained from the i860 by supplying customers with a library of signal processing functions written in assembly language. The hardware packed up to 360 compute nodes in [[rack unit|9U]] of [[19-inch rack|rack]] space, making it suitable for mobile applications such as airborne radar processing.

During the early 1990s, [[Stratus Technologies]] built i860-based servers, the XA/R series, running their proprietary [[Stratus VOS|VOS]] operating system.<ref>{{cite web
 |title=Stratus Machine History
 |url=http://ftp.stratus.com:80/vos/doc/reference/machine_history.txt
 |archive-url=https://web.archive.org/web/20030612194052/http://ftp.stratus.com:80/vos/doc/reference/machine_history.txt
 |url-status=dead
 |archive-date=2003-06-12
 }}</ref>

Also in the 1990s, [[Alliant Computer Systems]] built their i860-based FX/800 and FX/2800 servers, replacing the FX/80 and FX/8 series that had
been based on the Motorola 68000 ISA. Both the Alliant and Mercury compute systems were in heavy use at NASA/JPL for the [[Spaceborne Imaging Radar|SIR-C]] missions.

The U.S. military used the i860 for numerous aerospace and [[digital signal processing]] applications as a coprocessor, where it saw use up until the late 1990s.<ref>{{Cite web|url=http://www.militaryaerospace.com/articles/print/volume-8/issue-5/features/technology-focus/cots-board-vendors-make-their-dsp-choices.html|title = StackPath| date=May 1997 }}</ref>

== References ==
{{reflist|30em}}
{{refbegin}}
* {{cite book | title=i860 Microprocessor Architecture | first=Neal | last=Margulis | year=1990 | isbn=978-0-07-881645-1 |publisher=Osborne/McGraw-Hill |url=https://archive.org/details/i860microprocess0000marg |url-access=registration}}
{{refend}}

==External links==
{{Commons category}}
* [http://www.geekdot.com/hardware/intel-80860/ Many i860 expansion cards]
* [http://www.cpu-collection.de/?l0=co&l1=Intel&l2=i860 i860 images and description].
* {{cite conference |last=Rhodehamel |first=Michael W. |url=https://ieeexplore.ieee.org/document/63392 |title=The bus interface and paging units of the i860 microprocessor |book-title=Proceedings 1989 IEEE International Conference on Computer Design: VLSI in Computers and Processors |pages=380–384 |date=1989 |location=Cambridge, MA, USA |doi=10.1109/ICCD.1989.63392|url-access=subscription }}

{{RISC-based processor architectures}}
{{Intel processors|discontinued}}
{{Authority control}}

[[Category:Graphics chips]]
[[Category:Intel graphics]]
[[Category:Intel microprocessors|I860]]
[[Category:Very long instruction word computing]]
[[Category:32-bit microprocessors]]
[[Category:64-bit microprocessors]]