Intel 8086 Development
PCW: How did the 8086 project get started?
SM: The state-of-the-art product at the time was the Intel 8080. But Zilog was eating Intel’s lunch with a processor it had, called the Z80. The Z80 was an 8080 in every sense of the word, but it also filled in the 12 unused opcodes with some useful string-processing instructions. So it did more than the 8080, and Zilog captured the 8-bit market.
Intel wasn’t too concerned because it was working on a new high-end processor called the 8800 (which would change names a few times before finally coming to market as the 432), and it fully expected that chip to be the future of the company. The schedules for the 8800 kept slipping uncontrollably, however, and management finally realized that they needed to come out with a midrange processor to counter the Zilog threat. But nobody expected it to be anything more than a stopgap measure, because once the 8800 came out there would be no need for such a midrange solution.
In the meantime I had just completed an evaluation of the 8800 processor design, and written a report on it. My report was critical and showed that the processor would be too slow. Because of my report, management decided that I would be the ideal person to design the architecture for the stopgap measure. If management had any inkling that this architecture would live on through many generations and into today’s Pentium processors, and be the instruction set executed by more instances of computers than any other in history by far, they never would have entrusted the task to a single person. Instead it would have been designed by committee, and it would have come out much later than it did.
The person I worked for, Terry Opdendyk, was in charge of the software group. He walked into my office one day and asked if I would design the instruction set for the new processor that Intel needed. This was a complete break with tradition, because up until that time hardware people did all the architectural design, and they would put in whatever features they had space for on the chip. It didn’t matter whether the feature was useful or not, as long as the chip real estate could support it. Now, for the first time, we were going to look at processor features from a software perspective. The question was not “What features do we have space for?” but “What features do we want in order to make the software more efficient?” (At that time the 8800 was also being designed by software people, but that processor was many years away from coming out the door.)
So there I was, a software person who would be chartered with what was normally considered a hardware task. Although Terry remained my boss, for the work on the 8086 I would report to Bill Pohlman, who was the project manager for the new stopgap processor.
PCW: Was there a specific goal in mind for the 8086?
SM: The only requirements that management gave me were to make it somehow 8080-compatible (so Intel could tell customers that they could run their existing assembly-language programs) and that it address at least 128KB of memory (one of Intel’s customers had an application that was exceeding the 64KB limit of the 8080).
PCW: When did development start on the 8086?
SM: The last revision of my 8800 evaluation was dated April 14, 1976. I believe I started working on the 8086 in May, and on August 13 (three months later) I published Rev. 0 of the instruction set. It was actually more than just the instruction set, since it covered the register structure, I/O space, interrupt mechanism, memory addressing modes, etc. So we quickly started talking about the architecture rather than just the instruction set.
PCW: How big was the 8086 development team, and who else was involved?
SM: When it started, it was just Bill Pohlman and myself. Bill was the project manager and I was the engineer. After I finished the first cut of the architecture specs, Bill brought on board a logic designer named Jim McKevitt. Jim and Bill were my primary points of contact in the hardware group. Many other people (a chip designer and such) were added to the project later, although I didn’t interact with them directly.
After I finished two revisions of the architecture specs, Terry enlisted Bruce Ravenel, a second software person I could bounce ideas off of, and together we kept refining the specs.
PCW: Describe the atmosphere and general feeling in your office during the creation of the 8086.
SM: Company culture at Intel varied depending on the level you looked at. On the group level, things were great—the software team at Intel was top-notch, and we were all proud of what we were doing and how we were doing it. But at a higher level, the corporate culture often got in the way. Andy Grove was famous in those days for implementing a “late list.” Regardless of how late you worked the previous evening, if you were not in by 8:05 a.m. the next day you had to sign the “late list” when you entered the building. At first we all laughed about it, because nothing was done with the list. And Opdendyk even advised us that if we could not get in by 8:05, we should simply not show up until after 9, when the list was taken down. But sometime later upper management started insisting that the list be used in employee evaluations, and it was no longer something we could laugh about. The culture had other similar aspects, and pretty soon Intel stopped being a fun place to work.
PCW: What was your official role in the 8086’s development? Your biggest contribution to the project?
SM: My official role was the chief architect, although that title wouldn’t exist at Intel until several processors later. Actually, until Ravenel came on the scene, I was the only architect. McKevitt would try to design the logic to implement the architecture, and we had a lot of give-and-take between us as he would point out things that were very expensive to implement and I would then try to come up with alternate specifications.
The spec I was writing was at a high level. It specified the register set but it didn’t talk about the bus structure to pass data between the registers or about the machine cycles during which time the data actually got passed. That was all in McKevitt’s area. As I was writing and revising a document titled “8086 Architectural Specifications,” and he was writing a companion document called “8086 Device Specifications.”
PCW: What constitutes the “architecture” of a microprocessor?
SM: The architecture, as I see it, is the high-level specs of the processor. This consists of the instructions set, memory structure, memory segmentation, register structure, I/O space, interrupt mechanism, instruction operands, memory addressing modes, and so on.
PCW: Take us into the design process a little, step by step. With what tools and methods did you design the 8086?
SM: Although physical paper was still in fashion, computer files were starting to catch on, and I wrote the specs by typing them directly into a file. Personal computers were still a few years off, so I did my work on a remote terminal to a PDP-11 mainframe. I wrote the document using a primitive text editor that we had at that time called TECO. I included diagrams in the spec using ASCII characters—that is, drawing boxes made up of dashes, vertical bars, and plus signs.
There was a simulator program that somebody wrote, but I never used it. Instead the hardware group used it to verify the logic design and microcode to make sure that it correctly implemented the specs. The software group did other simulations to make sure that the addressing modes the processor provided would allow for an efficient implementation of high-level languages.
I had no direct involvement with testing the 8086, since the hardware department handled that entirely.
PCW: What obstacles, if any, did you face while developing the 8086?
SM: Very few. Because nobody expected the design to live long, no one placed any barriers in my way and I was free to do what I wanted.