Hacker News Reader

Comment by mikepurvis | Hacker News Reader

It still boggles my mind that processors in the 1970s already had microcode— obviously it was vastly simpler and not doing the crazy branch prediction, speculative execution, and operation reordering that modern processors do, but it's still amazing to me that this architecture was there at all.

View on HN

Historically, microcode was invented around 1951 and was heavily used in most of the IBM System/360 computers (1964). Once your instruction set is even moderately complicated, using microcode is a lot easier than hard-wired control circuitry.

You can view microcode as one of the many technologies that started in mainframes, moved into minicomputers, and then moved into microprocessors. In a sense, the idea behind RISC was the recognition that this natural progression was not necessarily the best way to build microprocessors.

There's something more fundamental going on here:

The concept of the ISA as a standard implemented by hardware, as opposed to the ISA being a document of what a specific hardware design does, goes back to the IBM System/360 family of computers from 1964. That was the first range of computers, from large to (let's be honest) somewhat less large, that could all run most of the same software, modulo some specialized instructions and peripheral hardware like disk drives not present on the cheapest systems, at different levels of performance. As others have said, microcode is plenty old, but the idea of architectural families is one of the things which really gets us to where we are now.

Microcode (the concept) is very much older than the 1970's. Per Wikipedia ([1]) the earliest system with something like 'microcode' dates back to 1947.

What is 'special' for the 8086 is that this was a low cost microprocessor using microcode, as opposed to a multi-million dollar mainframe CPU.

[1] https://en.wikipedia.org/wiki/Microcode#History

edit: fix typo

You mean the 8086, not the 8-bit 8080, right? The 8080 wasn't microcoded.

Indeed, that was a typo. Fixed now. Thanks.

Babbage's analytical engine used a form of microcode ~100 years earlier. Complex operations such as multiplication and division were implemented by lower-level instructions encoded as a series of pegs on a rotating barrel. Each micro-instruction ("vertical" in Babbage's terminology) could take several seconds to execute so a complete multiplication or division would take minutes.

Thanks for that link! The concept of "Directly Executable High Level Language" is also kind of fascinating— seems almost like an early pitch for something like a native LISP or Java machine.

I love that the TMS34082 math coprocessor had user-definable microcode! This was intended to work with 3D graphics, so you could really get the most out of the ALU by chaining operations for your specific need (e.g. divide-and-sqrt single instruction)

See chapter 8: http://www.bitsavers.org/components/ti/TMS340xx/TMS34082_Des...

Numerous machines had user-definable microcode. For example, the PDP-11/60 had a "Writeable Control Store" (WCS) option, as did the early VAX-11s. I once knew someone who actually did create his own VAX instruction (I want to say it was an FFT, but that might be wrong).

Besides the sibling comments, microcode is how all Xerox computers worked, each language flavour had their own bytecode (Smalltalk, Interlisp, Mesa, Mesa/Cedar), and the respective microcode for the specific bytecode would be loaded on boot.

Reply on news.ycombinator.com