iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
The Intel 8087 made floating-point arithmetic dramatically faster than software emulation on the 5 MHz 8086 systems Intel measured in 1980. Intel reported, for example, about 19 microseconds for a single-precision multiply on the 8087 versus 1,600 microseconds for an optimized 8086 software routine, and about 36 microseconds versus 19,600 microseconds for square root. Those are instruction-level historical timings, not a universal application speedup. The 8087 was an optional coprocessor that worked alongside an 8086 or 8088, while software emulation let the same style of numeric program run without the chip. The complete comparison also includes 80-bit internal precision, rounding behavior, instruction coverage, toolchain support, and the amount of work the host CPU and coprocessor could overlap.
What was the Intel 8087, and what did software floating-point replace?
The 8087 was a numeric coprocessor for Intel 8086 and 8088 systems, not a standalone replacement for the host processor. The 8086 or 8088 fetched the shared instruction stream and coordinated the system, while the 8087 decoded and executed floating-point and related numeric instructions. This arrangement added hardware arithmetic to machines whose base CPU otherwise had to perform those operations with integer instructions and software routines.
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
Microprocessors: The 8086/8088, 80186/ 80286, 80386/80486 and the Pentium Family | $8.50 | Buy on Amazon |
Software floating-point arithmetic used carefully optimized assembly procedures to emulate the 8087 instruction set. Intel’s E8087 package provided an emulator, assembler support, and related development tools so programmers could build and run numeric code before prototype hardware was available or on a system that did not have the optional coprocessor installed. A compatible program could therefore target one source and toolchain path while choosing real hardware or emulation during the build and link process.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
The practical difference was latency. A hardware instruction performed the arithmetic in specialized circuitry; an emulator had to decompose the operation into many 8086 instructions, manage intermediate values, and implement exceptional cases in software. That made the 8087 especially valuable for scientific calculations, engineering programs, graphics routines, and any application that repeatedly divided, took square roots, or evaluated transcendental functions.
#1 Best Overall
Intel’s 1980 manual described the software comparison as highly optimized emulator assembly, so the historical baseline was not an unoptimized schoolbook routine. Even against that favorable software baseline, the coprocessor was substantially faster for the operations Intel selected.
How much faster was the 8087 than software emulation?
Intel’s July 1980 8086 Family User’s Manual: Numerics Supplement compared approximate execution times at a 5 MHz 8086 clock. The table below preserves the operation, precision, and setup used by Intel. The final column is a simple ratio of emulator time to 8087 time; it illustrates the scale of the instruction difference but is not an application benchmark.
| Operation | 8087 time | Optimized 8086 emulation | Emulation time divided by 8087 time |
|---|---|---|---|
| Single-precision multiply | 19 microseconds | 1,600 microseconds | about 84 times |
| Double-precision multiply | 27 microseconds | 2,100 microseconds | about 78 times |
| Add | 17 microseconds | 1,600 microseconds | about 94 times |
| Single-precision divide | 39 microseconds | 3,200 microseconds | about 82 times |
| Compare | 9 microseconds | 1,300 microseconds | about 144 times |
| Square root | 36 microseconds | 19,600 microseconds | about 544 times |
| Tangent | 90 microseconds | 13,000 microseconds | about 144 times |
| Exponentiation | 100 microseconds | 17,100 microseconds | about 171 times |
These figures explain why square root and transcendental functions were compelling reasons to install an 8087. They also show that the advantage varied by operation rather than being one fixed multiplier. Intel’s datasheet contains a separate timing table for an 8 MHz 8086/8087 comparison; those values should not be mixed with the 5 MHz results above because clock rate and test conditions differ.
Recommended Free Tools
The manual cautioned that “the actual performance of the NDP in a given system depends on numerous application-specific factors.” That qualification matters: a program dominated by memory traffic, integer work, input/output, or function-call overhead will not scale by the ratio of one isolated floating-point instruction.
Why do instruction timings differ from whole-program speed?
An instruction timing measures the numeric operation itself. A complete program also spends time loading operands, storing results, converting formats, branching, managing arrays, and waiting for other devices. If only a small fraction of execution is floating point, accelerating that fraction produces a much smaller total gain.
Host and coprocessor overlap
The 8087’s control and numeric units were designed to operate independently from the 8086/8088. While the coprocessor worked on a numeric instruction, the host could in some circumstances perform other useful work. A serial stream of dependent arithmetic instructions, however, leaves less opportunity for overlap than a workload with independent integer and floating-point tasks. Queueing, synchronization, and memory access can therefore change observed throughput.
Instruction mix and precision
Addition, multiplication, division, comparison, square root, tangent, and exponentiation have different hardware costs, as the table shows. A program using mostly additions will have a different profile from one calling trigonometric operations. Precision also matters: single- and double-precision paths do not have identical timings, and conversion between memory formats and the coprocessor’s internal format adds work.
Why an “80-times faster” claim is unsafe
The ratios in the table are useful for understanding the 1980 design, but they are not a promise that every application ran 80, 100, or 500 times faster. A defensible comparison names the processor clock, operation, precision, software implementation, and whether the number is an isolated latency or an end-to-end benchmark.
How did the 8087 execute floating-point operations?
The 8087 contained a control unit and a numeric execution unit, plus an eight-entry register stack. Each stack register was 80 bits wide and used the 8087’s temporary-real format for internal calculations. Instructions could load values from memory, operate on stack registers, compare them, and store results back to memory.
Loads and stores converted among several representations, including integer formats, binary floating-point formats, and packed decimal data. This conversion capability let software exchange values with existing data structures while retaining the coprocessor’s wider internal representation during a calculation.
Built-in operations
The instruction set covered basic arithmetic and comparisons as well as more complex functions. Square root, tangent, and exponentiation in Intel’s timing table were hardware-supported numeric instructions rather than calls to a general-purpose external library. That feature coverage was another difference from a minimal software routine, which had to implement each operation as a sequence of 8086 instructions and approximation steps.
Free tools Windows power users keep installed
One-click scans. No signup required.
Shared-system integration
The 8087 depended on a compatible 8086 or 8088 bus and coprocessor interface. It could not be dropped into an arbitrary computer as an independent math processor. The host still handled program flow, memory, operating-system services, and nonnumeric instructions; the 8087 accelerated the subset of instructions it recognized.
Can hardware and software produce different numeric results?
Yes. The formula may be identical while intermediate values differ because the two implementations round at different points. The 8087 keeps intermediate results in 80-bit temporary-real registers, then converts them when a value is stored to memory or another format. A software emulator can preserve an equivalent extended value, round after every operation, or use a different sequence of approximations, depending on its design.
Precision and conversion points
Suppose a calculation performs several multiplies and additions before storing a result. Keeping those intermediates in 80-bit registers can retain bits that would be discarded if software rounded each step to single or double precision. The final stored value may therefore differ even when both implementations follow the same source-level expression.
Rounding modes and exceptions
Rounding mode, underflow and overflow handling, invalid-operation behavior, and the point at which an exception is reported are part of numerical behavior. A comparison should specify these settings rather than treating “floating point” as one universal format. Intel’s manual presented the 8087 as designed to provide stable, accurate results for straightforward algorithms; that is a manufacturer description of the hardware design, not proof that every software implementation will match it bit for bit.
Relationship to IEEE floating point
The 8087 was designed around the proposed IEEE binary floating-point standard of its era. A historical overview from SIAM notes that the 8087 implemented many IEEE features and that the extended format recommended by the standard was based on the 8087 design. This establishes an important historical relationship, but it does not by itself document every clause of the finalized IEEE 754 standard or prove complete conformance for every operation.
What did E8087 software emulation provide?
Intel’s E8087 package emulated floating-point instructions on an 8086 or 8088 and supported development without installed 8087 hardware. The software handbook describes an assembler and emulator package in which the floating-point operations were implemented as software procedures. This made it possible to write and test numeric programs while hardware availability was uncertain.
One source path, two execution choices
Historical accounts of the toolchain describe translators that produced emulatable numeric code and link-time libraries that selected real hardware or software emulation. A developer could therefore distribute a version for systems with the coprocessor and another for systems without it, rather than maintaining unrelated source programs.
The cost of compatibility
Emulation removed the hardware requirement but paid for it in execution time and code complexity. Every floating-point instruction consumed host-CPU cycles, and especially expensive functions such as square root and exponentiation magnified that cost. The software path was valuable for portability and development, not because it matched the 8087’s speed.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11When was software the better choice?
Software emulation was the practical choice when a machine lacked the coprocessor socket, when the 8087 was unavailable during development, or when the application performed too little floating-point work to justify optional hardware. It also provided a compatibility path for users whose systems differed in configuration.
- Choose hardware acceleration for numeric workloads dominated by repeated arithmetic, division, square roots, or transcendental functions on a compatible 8086/8088 system.
- Choose emulation when installation constraints, production volume, or development timing matter more than numeric throughput.
- Measure the program when integer processing, memory access, input/output, or synchronization may dominate total runtime.
- Check numerical requirements when reproducibility matters, because internal precision and rounding points can alter results.
What should a restorer or historian verify before comparing an 8087 system?
Start by identifying the host CPU and clock, then confirm that the motherboard, socket, bus interface, and software toolchain support the coprocessor. A timing claim made on a 5 MHz 8086 should not be applied directly to an 8 MHz configuration or to a different emulator library.
- Record whether the host is an 8086 or 8088 and its operating frequency.
- Determine whether the program was assembled and linked for hardware floating point, E8087 emulation, or a selectable library.
- Match the operation and precision being tested; do not compare a single-precision multiply with a double-precision routine.
- Measure a representative section of the application, including loads, stores, conversions, and synchronization.
- Check output files and stored intermediates if numerical differences appear; a wider internal value may have been rounded only when written to memory.
Current prices, supply, and condition of surviving 8087 chips are separate market questions and are not established by Intel’s historical timing documents. The technical comparison remains valid as a description of the original hardware-versus-emulation trade-off.
What is the overall comparison?
For the operations Intel measured, the 8087 delivered a large hardware advantage over optimized software floating point on a 5 MHz 8086, with the biggest gap in square root and transcendental functions. Software emulation nevertheless solved an important compatibility and development problem by allowing numeric programs to run without the optional coprocessor. The fairest comparison therefore combines speed, workload, overlap, precision, rounding, and toolchain availability rather than quoting one universal multiplier.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Frequently Asked Questions
Was the 8087 required for every 8086 or 8088 computer?
No. It was an optional coprocessor, and an 8086 or 8088 could run programs using software emulation instead. A system needed the appropriate socket, interface, and software support to use the physical chip.
Why are the 8087 registers described as 80-bit when programs used single or double precision?
Single- and double-precision values describe common memory formats. The 8087 converted those values into its 80-bit temporary-real register format for internal work, then converted them back when storing results.
Does the 8087 timing table prove that every scientific program became hundreds of times faster?
No. The numbers are approximate timings for selected instructions on a 5 MHz 8086 compared with optimized emulator procedures. Whole-program speed also depends on instruction mix, memory traffic, host work, and opportunities for CPU-coprocessor overlap.
How did developers support machines with and without an 8087?
Intel’s toolchain could translate numeric instructions into emulatable code and use link-time libraries to select hardware or software execution. That allowed a common source and development path while producing configurations for different machines.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
