A microprogram implements a CPU instruction set. Just as a single high level language statement is compiled to a series of machine instructions (load, store, shift, etc), in a CPU using microcode, each machine instruction is in turn implemented by a series of microinstructions, sometimes called a microprogram. Microprograms are often referred to as microcode.

The elements composing a microprogram exist on a lower conceptual level than the more familiar assembler instructions. Each element is differentiated by the "micro" prefix to avoid confusion: microprogram, microcode, microinstruction, microassembler, etc.

Microprograms are carefully designed and optimized for the fastest possible execution, since a slow microprogram would yield a slow machine instruction which would in turn cause all programs using that instruction to be slow. The microprogrammer must have extensive low-level hardware knowledge of the computer circuitry, as the microcode controls this. The microcode is written by the CPU engineer during the design phase.

On most computers using microcode, the microcode doesn't reside in the main system memory, but exists in a special high speed memory, called the control store. This memory might be read-only memory, or it might be read-write memory, in which case the microcode would be loaded into the control store from some other storage medium as part of the initialization of the CPU. If the microcode is in read-write memory, it can be altered to correct bugs in the instruction set, or to implement new machine instructions. Microcode can also allow one computer microarchitecture to emulate another, usually more-complex architecture.

Microprograms consist of series of microinstructions. These microinstructions control the CPU at a very fundamental level. For example, a single typical microinstruction might specify the following operations:

• Connect Register 1 to the "A" side of the ALU
• Connect Register 7 to the "B" side of the ALU
• Set the ALU to perform two's-complement addition
• Set the ALU's carry input to zero
• Store the result value in Register 8
• Update the "condition codes" with the ALU status flags ("Negative", "Zero", "Overflow", and "Carry")
• Microjump to MicroPC nnn for the next microinstruction

To simultaneously control all of these features, the microinstruction is often very wide, for example, 56 bits or more.

Confusingly, for some today hardware vendors, especially IBM, microcode is a synonym of a firmware, whether it actually implements microprogramming in a machine or not.^[1] Even as simple firmware, as the one used in standalone hard drive, is sometimes described as microcode.^[2]

The reason for microprogramming

Microcode was originally developed as a simpler method of developing the control logic for a computer. Initially CPU instruction sets were "hard wired". Each machine instruction (add, shift, move) was implemented directly with circuitry. This provided fast performance, but as instruction sets grew more complex, hard-wired instruction sets became more difficult to design and debug.

Microcode alleviated that problem by allowing CPU design engineers to write a microprogram to implement a machine instruction rather than design circuitry for it. Even late in the design process, microcode could easily be changed, whereas hard wired instructions could not. This greatly facilitated CPU design and led to more complex instruction sets.

Another advantage of microcode was the implementation of more complex machine instructions. In the 1960s through the late 1970s, much programming was done in assembly language, a symbolic equivalent of machine instructions. The more abstract and higher level the machine instruction, the greater the programmer productivity. The ultimate extension of this were "Directly Executable High Level Language" designs. In these each statement of a high level language such as PL/I would be entirely and directly executed by microcode, without compilation. The IBM Future Systems project and Data General Fountainhead Processor were examples of this.

Microprogramming also helped alleviate the memory bandwidth problem. During the 1970s, CPU speeds grew more quickly than memory speeds. Numerous acceleration techniques such as memory block transfer, memory pre-fetch and multi-level caches helped reduce this. However high level machine instructions (made possible by microcode) helped further. Fewer more complex machine instructions require less memory bandwidth. For example complete operations on character strings could be done as a single machine instruction, thus avoiding multiple instruction fetches.

Architectures using this approach included the IBM System/360 and Digital Equipment Corporation VAX, the instruction sets of which were implemented by complex microprograms. The approach of using increasingly complex microcode-implemented instruction sets was later called CISC.

Other benefits

A processor's microprograms operate on a more primitive, totally different and much more hardware-oriented architecture than the assembly instructions visible to normal programmers. In coordination with the hardware, the microcode implements the programmer-visible architecture. The underlying hardware need not have a fixed relationship to the visible architecture. This makes it possible to implement a given instruction set architecture on a wide variety of underlying hardware micro-architectures.

Doing so is important if binary program compatibility is a priority. That way previously existing programs can run on totally new hardware without requiring revision and recompilation. However there may be a performance penalty for this approach. The tradeoffs between application backward compatibility vs CPU performance are hotly debated by CPU design engineers.

The IBM System/360 has a 32-bit architecture with 16 general-purpose registers, but most of the System/360 implementations actually use hardware that implemented a much simpler underlying microarchitecture; for example, the System/360 Model 30 had 8-bit data paths to the arithmetic logic unit (ALU) and main memory and implemented the general-purpose registers in a special unit of higher-speed core memory, and the System/360 Model 40 had 8-bit data paths to the ALU and 16-bit data paths to main memory and also implemented the general-purpose registers in a special unit of higher-speed core memory.. The Model 50 and Model 65 had full 32-bit data paths and implemented the general-purpose registers in faster transistor circuits. In this way, microprogramming enabled IBM to design many System/360 models with substantially different hardware and spanning a wide range of cost and performance, while making them all architecturally compatible. This dramatically reduced the amount of unique system software that had to be written for each model.

A similar approach was used by Digital Equipment Corporation in their VAX family of computers. Initially a 32-bit TTL processor in conjunction with supporting microcode implemented the programmer-visible architecture. Later VAX versions used different microarchitectures, yet the programmer-visible architecture didn't change.

Microprogramming also reduced the cost of field changes to correct defects (bugs) in the processor; a bug could often be fixed by replacing a portion of the microprogram rather than by changes being made to hardware logic and wiring.

History

In 1947, the design of the MIT Whirlwind introduced the concept of a control store as a way to simplify computer design and move beyond ad hoc methods. The control store was a two-dimensional lattice: one dimension accepted "control time pulses" from the CPU's internal clock, and the other connected to control signals on gates and other circuits. A "pulse distributor" would take the pulses generated by the CPU clock and break them up into eight separate time pulses, each of which would activate a different row of the lattice. When the row was activated, it would activate the control signals connected to it.

Described another way, the signals transmitted by the control store are being played much like a player piano roll. That is, they are controlled by a sequence of very wide words constructed of bits, and they are "played" sequentially. In a control store, however, the "song" is short and repeated continuously.

In 1951 Maurice Wilkes enhanced this concept by adding conditional execution, a concept akin to a conditional in computer software. His initial implementation consisted of a pair of matrices, the first one generated signals in the manner of the Whirlwind control store, while the second matrix selected which row of signals (the microprogram instruction word, as it were) to invoke on the next cycle. Conditionals were implemented by providing a way that a single line in the control store could choose from alternatives in the second matrix. This made the control signals conditional on the detected internal signal. Wilkes coined the term microprogramming to describe this feature and distinguish it from a simple control store.

Examples of microprogrammed systems

• Most models of the IBM System/360 series were microprogrammed:

* The Model 25 was unique among System/360 models in using the top 16k bytes of core storage to hold the control storage for the microprogram. The 2025 used a 16-bit microarchitecture with seven control words (or microinstructions).

* The Model 30, the slowest model in the line, used an 8-bit microarchitecture with only a few hardware registers; everything that the programmer saw was emulated by the microprogram.

* The Model 40 used 56-bit control words. The 2040 box implements both the System/360 main processor and the multiplex channel (the I/O processor).

* The Model 50 had two internal datapaths which operated in parallel: a 32-bit datapath used for arithmetic operations, and an 8-bit data path used in some logical operations. The control store used 90-bit microinstructions.

* The Model 85 had separate instruction fetch (I-unit) and execution (E-unit) to provide high performance. The I-unit is hardware controlled. The E-unit is microprogrammed with 108-bit control words.

• The Digital Equipment Corporation PDP-11 processors, with the exception of the PDP-11/20, were microprogrammed^[3].
• The Burroughs B700 "microprocessor" executed application-level opcodes using sequences of 16-bit microinstructions stored in main memory, each of these was either a register-load operation or mapped to a single 56-bit "nanocode" instruction stored in read-only memory. This allowed comparatively simple hardware to act either as a mainframe peripheral controller or to be packaged as a standalone computer.
• The Burroughs B1700 was implemented with radically different hardware including bit-addressable main memory but had a similar multi-layer organisation.
• In common with many other complex mechanical devices Charles Babbage's analytical engine used banks of cams to control each operation, i.e. it had a read-only control store. As such it deserves to be recognised as the first microprogrammed computer to be designed, even if it has not yet been realised in hardware.
• The VU0 and VU1 vector units in the Sony Playstation 2 are microprogrammable; in fact, VU1 was only accessible via microcode for the first several generations of the SDK.

Implementation

Each microinstruction in a microprogram provides the bits which control the functional elements that internally comprise a CPU. The advantage over a hard-wired CPU is that internal CPU control becomes a specialized form of a computer program. Microcode thus transforms a complex electronic design challenge (the control of a CPU) into a less-complex programming challenge.

To take advantage of this, computers were divided into several parts:

A microsequencer picked the next word of the control store. A sequencer is mostly a counter, but usually also has some way to jump to a different part of the control store depending on some data, usually data from the instruction register and always some part of the control store. The simplest sequencer is just a register loaded from a few bits of the control store.

A register set is a fast memory containing the data of the central processing unit. It may include the program counter, stack pointer, and other numbers that are not easily accessible to the application programmer. Often the register set is triple-ported, that is, two registers can be read, and a third written at the same time.

An arithmetic and logic unit performs calculations, usually addition, logical negation, a right shift, and logical AND. It often performs other functions, as well.

There may also be a memory address register and a memory data register, used to access the main computer storage.

Together, these elements form an "execution unit." Most modern CPUs have several execution units. Even simple computers usually have one unit to read and write memory, and another to execute user code.

These elements could often be bought together as a single chip. This chip came in a fixed width which would form a 'slice' through the execution unit. These were known as 'bit slice' chips. The AMD Am2900 is the best known example of a bit slice processor.

The parts of the execution units, and the execution units themselves are interconnected by a bundle of wires called a bus.

Programmers develop microprograms. The basic tools are software: A microassembler allows a programmer to define the table of bits symbolically. A simulator program executes the bits in the same way as the electronics (hopefully), and allows much more freedom to debug the microprogram.

After the microprogram is finalized, and extensively tested, it is sometimes used as the input to a computer program that constructs logic to produce the same data. This program is similar to those used to optimize a programmable logic array. No known computer program can produce optimal logic, but even pretty good logic can vastly reduce the number of transistors from the number required for a ROM control store. This reduces the cost and power used by a CPU.

Microcode can be characterized as horizontal or vertical. This refers primarily to whether each microinstruction directly controls CPU elements (horizontal microcode), or requires subsequent decoding by combinational logic before doing so (vertical microcode). Consequently each horizontal microinstruction is wider (contains more bits) and occupies more storage space than a vertical microinstruction.

Horizontal microcode

Horizontal microcode is typically contained in a fairly wide control store, it is not uncommon for each word to be 56 bits or more. On each tick of a sequencer clock a microcode word is read, decoded, and used to control the functional elements which make up the CPU.

In a typical implementation a horizontal microprogram word comprises fairly tightly defined groups of bits. For example, one simple arrangement might be:

| register source A | register source B | destination register | arithmetic and logic unit operation | type of jump | jump address |

For this type of micromachine to implement a JUMP instruction with the address following the opcode, the microcode might require two clock ticks; the engineer designing it would write microassembler source code looking something like this:

1. Any line starting with a number-sign is a comment
2. This is just a label, the ordinary way assemblers symbolically represent a
3. memory address.

InstructionJUMP:

1. To prepare for the next instruction, the instruction-decode microcode has already
2. moved the program counter to the memory address register. This instruction fetches
3. the target address of the jump instruction from the memory word following the
4. jump opcode, by copying from the memory data register to the memory address register.
5. This gives the memory system two clock ticks to fetch the next
6. instruction to the memory data register for use by the instruction decode.
7. The sequencer instruction "next" means just add 1 to the control word address.

MDR, NONE, MAR, COPY, NEXT, NONE

1. This places the address of the next instruction into the PC.
2. This gives the memory system a clock tick to finish the fetch started on the
3. previous microinstruction.
4. The sequencer instruction is to jump to the start of the instruction decode.

MAR, 1, PC, ADD, JMP, InstructionDecode

1. The instruction decode is not shown, because it's usually a mess, very particular
2. to the exact processor being emulated. Even this example is simplified.
3. Many CPUs have several ways to calculate the address, rather than just fetching
4. it from the word following the op-code. Therefore, rather than just one
5. jump instruction, those CPUs have a family of related jump instructions.

For each tick it is common to find that only some portions of the CPU are used, with the remaining groups of bits in the microinstruction being no-ops. With careful design of hardware and microcode this property can be exploited to paralelise operations which use different areas of the CPU, for example in the case above the ALU is not required during the first tick so it could potentially be used to complete an earlier arithmetic instruction.

Vertical microcode

In vertical microcode, each microinstruction is encoded -- that is, the bit fields may pass through intermediate combinatory logic which in turn generates the actual control signals for internal CPU elements (ALU, registers, etc.). In contrast, with horizontal microcode the bit fields themselves directly produce the control signals. Consequently vertical microcode requires smaller instruction lengths and less storage, but requires more time to decode, resulting in a slower CPU clock.

Some vertical microcodes are just the assembly language of a simple conventional computer that is emulating a more complex computer. This technique was popular in the time of the PDP-8. Another form of vertical microcode has two fields:

| field select | field value |

The "field select" selects which part of the CPU will be controlled by this word of the control store. The "field value" actually controls that part of the CPU. With this type of microcode, a designer explicitly chooses to make a slower CPU to save money by reducing the unused bits in the control store; however, the reduced complexity may increase the CPU's clock frequency, which lessens the effect of an increased number of cycles per instruction.

As transistors became cheaper, horizontal microcode came to dominate the design of CPUs using microcode, with vertical microcode no longer being used.

Writable control stores

A few computers were built using "writable microcode" -- rather than storing the microcode in ROM or hard-wired logic, the microcode was stored in a RAM called a Writable Control Store or WCS. Many of these machines were experimental laboratory prototypes, but there were also commercial machines that used writable microcode, such as early Xerox workstations, the DEC VAX 8800 ("Nautilus") family, the Symbolics L- and G-machines, and a number of IBM System/370 implementations. Many more machines offered user-programmable writeable control stores as an option (including the HP 2100 and DEC PDP-11/60 minicomputers). WCS offered several advantages including the ease of patching the microprogram and, for certain hardware generations, faster access than ROMs could provide. User-programmable WCS allowed the user to optimize the machine for specific purposes.

A CPU that uses microcode generally takes several clock cycles to execute a single instruction, one clock cycle for each step in the microprogram for that instruction. Some CISC processors include instructions that can take a very long time to execute. Such variations in instruction length interfere with pipelining and interrupt latency.

Microcode versus VLIW and RISC

The design trend toward heavily microcoded processors with complex instructions began in the early 1960s and continued until roughly the mid-1980s. At that point the RISC design philosophy started becoming more prominent. This included the points:

• Analysis shows complex instructions are rarely used, hence the machine resources devoted to them are largely wasted.
• Programming has largely moved away from assembly level, so it's no longer worthwhile to provide complex instructions for productivity reasons.
• The machine resources devoted to rarely-used complex instructions is better used for expediting performance of simpler, commonly-used instructions.
• Complex microcoded instructions requiring many, varying clock cycles are difficult to pipeline for increased performance.
• Simpler instruction sets allow direct execution by hardware, avoiding the performance penalty of microcoded execution.

Many RISC and VLIW processors are designed to execute every instruction (as long as it is in the cache) in a single cycle. This is very similar to the way CPUs with microcode execute one microinstruction per cycle. VLIW processors have instructions that behave like very wide horizontal microcode, although typically VLIW instructions do not have as fine-grained control over hardware as microcode. RISC processors can have instructions that look like narrow vertical microcode.

Modern implementations of CISC instruction sets such as the x86 instruction set implement the simpler instructions in hardware rather than microcode, using microcode only to implement the more complex instructions.

See also

• Firmware
• Control unit
• Finite state machine
• Microsequencer
• Microassembler
• Control store
• Execution unit
• Arithmetic logic unit
• Floating point unit
• Instruction pipeline
• Superscalar
• Microarchitecture
• CPU design

References

• Everett, R.R., and Swain, F.E. (1947). "Whirlwind I Computer Block Diagrams". Report R-127. MIT Servomechanisms Laboratory. Retrieved on 2006-06-21.
• Smith, Richard E. (1988). "A Historical Overview of Computer Architecture". Annals of the History of Computing 10 (4): 277–303. Retrieved on 2006-06-21. 
• Smotherman, Mark (2005). "A Brief History of Microprogramming". Retrieved on 2006-07-30.
• Wilkes, M.V. (1986). "The Genesis of Microprogramming". Annals of the History of Computing 8 (2): 116–126. Retrieved on 2006-08-07. 
• Wilkes, M.V., and Stringer, J. B. (April 1953). "Microprogramming and the Design of the Control Circuits in an Electronic Digital Computer". Proc. Cambridge Phil. Soc 49 (pt. 2): 230-238. Retrieved on 2006-08-23. 
• Husson, S.S (1970). Microprogramming Principles and Practices. Prentice-Hall. ISBN 0-13-581454-5. 

External links