> ## Content Index
> Fetch the complete content index at: https://huizhou92.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# How Robert Tomasulo Designed Dynamic Scheduling for IBM's Model 91
- URL: https://huizhou92.com/robert-tomasulo-ibm-model-91-out-of-order-en/
- Published: 2026-11-19T13:59:27.000Z
- Updated: 2026-11-19T13:59:27.000Z
- Description: Robert Tomasulo used tags to reduce register-name conflicts in IBM's Model 91. Three animations explain the mechanism.
- Author: huizhou92
- Tags: #lang-en, Technology, Computing, Software Engineering, Computer History, Computer Architecture

*AI-generated conceptual illustration. Register slots and routes are abstract visual motifs, not a literal Model 91 circuit diagram.*

In [my previous article on the CDC 6600](https://medium.com/p/07ddef720857?ref=huizhou92.com), I described how Seymour Cray and James Thornton combined compact wiring, peripheral processors, and a scoreboard to build one of the most advanced supercomputers of its time.

That article left another thread open. IBM had announced the Model 92 to compete with the CDC 6600, but it never shipped under the original plan. After changes to the design, IBM delivered the Model 91 in 1967.

The Model 91's floating-point unit also aimed to keep several arithmetic units working at once. IBM faced an additional constraint: the System/360 instruction set provided just **four architectural floating-point registers**. Reusing a register could make otherwise independent operations wait for one another.

Robert Tomasulo, who worked on the floating-point unit, designed a dynamic scheduling mechanism to address this problem. Instructions would still wait for data they genuinely needed, while spending less time stalled by register reuse.

## From the Model 92 to the Model 91

IBM began a high-performance computer research effort called **Project X** in 1961 and later brought it into the System/360 family. CDC announced the 6600 in 1963\. In an internal memo, IBM chairman Thomas J. Watson Jr. asked why a competitor had managed to announce a more powerful machine first.

IBM announced the Model 92 in 1964\. It did not ship as originally planned. [IBM later introduced the Model 91 with core memory and the Model 95 with thin-film memory](https://mark.people.clemson.edu/acs.html?ref=huizhou92.com).

Only **15 Model 91s** were built, and four remained inside IBM.

![IBM System/360 Model 91 at NASA](https://images.hxzhouh.com/blog-images/2026/11/f9bb29df68e9e358df794dfb0ba4e1a6.jpg)

*IBM System/360 Model 91, photographed in the 1960s. Source: NASA; individual photographer uncredited. Public Domain, via* [*Wikimedia Commons*](https://commons.wikimedia.org/wiki/File:360-91-panel.jpg?ref=huizhou92.com)*.*

The Model 91 had a limited production run, but its floating-point unit left an influential approach to dynamic scheduling and register renaming. To understand what it did, we need to return to the CDC 6600's scoreboard.

## What the Scoreboard Could Solve

As the previous article explained, the CDC 6600 had several functional units. Some handled addition; others handled multiplication and division. They could work concurrently, so a slow division did not have to hold up every calculation.

The **scoreboard** coordinated these units. It tracked whether units were free and whether instructions had the data they needed. Instructions issued in program order, but they could begin execution and finish in a different order.

Some waits, however, did not come from a genuine need for another calculation's result.

If an instruction needed the answer from an earlier division, it had to wait for that division to finish. The data did not exist yet.

Another kind of wait arose when two otherwise unrelated instructions used the same register. A register is a small storage location inside the processor. If a later instruction wanted to write new data there while an earlier instruction still needed the old data, the hardware had to delay the write.

The calculation itself did not require this delay. Both instructions happened to use the same location. The scoreboard could detect the conflict and prevent an incorrect result, but handling the conflict required waiting. [Thornton's account of the CDC 6600 design](https://archive.computerhistory.org/resources/text/CDC/cdc.6600.thornton.design%5Fof%5Fa%5Fcomputer%5Fthe%5Fcontrol%5Fdata%5F6600.1970.102630394.pdf?ref=huizhou92.com) describes these checks.

![Why a ready result must wait before writing](https://images.hxzhouh.com/blog-images/2026/11/fd45484b2786798ae0f380c0930c484a.gif)

*Programmatically drawn teaching animation (Illustration). An earlier instruction waits for a division result before reading the old value 10 from register R. A later writer already has 99, but must wait until the old value has been read. Values are illustrative, not machine measurements. Based on* [*Thornton's original account*](https://archive.computerhistory.org/resources/text/CDC/cdc.6600.thornton.design%5Fof%5Fa%5Fcomputer%5Fthe%5Fcontrol%5Fdata%5F6600.1970.102630394.pdf?ref=huizhou92.com)*; not a cycle-accurate simulation.*

## IBM Had only Four Floating-point Registers

This problem was particularly awkward for IBM. The System/360 family needed software compatibility, while its instruction set offered only four floating-point registers, numbered 0, 2, 4, and 6\. Floating-point programs repeatedly reused these names.

![IBM Model 91 console at the Computer History Museum](https://images.hxzhouh.com/blog-images/2026/11/f21c103fd1a088db370fc77eb51f7529.jpg)

*IBM System/360 Model 91 console at the Computer History Museum, photographed in 2007\. Photo by Carlo Nardone,* [*CC BY-SA 2.0*](https://creativecommons.org/licenses/by-sa/2.0/?ref=huizhou92.com)*, via* [*Wikimedia Commons*](https://commons.wikimedia.org/wiki/File:IBM%5FSystem%5F360%5FModel%5F91%5F%281966%29%5Fconsole%5F-%5FComputer%5FHistory%5FMuseum%5F%282007-11-10%5F23.06.26%5Fby%5FCarlo%5FNardone%29.jpg?ref=huizhou92.com)*. Resized only.*

Imagine a program processing a sequence of numbers. It loads the first number into a register, multiplies it, saves the result, and moves on to the second number. Even though the two multiplications process different numbers, reusing the same register name can introduce a wait.

This does not leave the machine permanently stuck, or prevent every other unit from working. It does mean an arithmetic unit may sit idle even when there is independent work it could otherwise perform.

Tomasulo's question was whether hardware could remember **which data each instruction actually needed**, instead of relying only on the register names the program kept reusing.

## Tag the Results before They Exist

In 1967, Tomasulo published [*An Efficient Algorithm for Exploiting Multiple Arithmetic Units*](https://courses.grainger.illinois.edu/ece511/fa2005/papers/Tomasulo.1967.IBMJRD.pdf?ref=huizhou92.com) in the *IBM Journal of Research and Development*. It described the method used in the Model 91's floating-point unit.

The approach can be explained in three steps.

First, instructions unable to calculate yet enter **reservation stations** ahead of the arithmetic units. A station holds an instruction while it waits for the data it needs. The Model 91 had three stations for addition and two for multiplication and division. The latter two shared one execution unit; they could not run two multiply or divide operations simultaneously.

Second, a result still being calculated gets a tag. When an instruction enters a reservation station, it saves any operand already available. For an operand still being produced, it records the producer's tag.

![Tags preserve the identity of an older result after a register is reused](https://images.hxzhouh.com/blog-images/2026/11/1bf83c1c884cd79246f2165fd3479cd9.gif)

*Programmatically drawn teaching animation (Illustration). F0 first points to producer A, then a later instruction retargets it to B. An earlier consumer keeps waiting for A. When A's result arrives, the consumer receives it, but it cannot overwrite F0, which now expects B. Simplified from* [*Tomasulo's paper*](https://courses.grainger.illinois.edu/ece511/fa2005/papers/Tomasulo.1967.IBMJRD.pdf?ref=huizhou92.com)*; not a literal hardware diagram or cycle-accurate simulation.*

Third, a completed result and its tag travel over the **Common Data Bus (CDB)**. Waiting units compare the broadcast tag with the tags they have saved. Matching consumers receive the data. Starting their next calculation still depends on other operands and the availability of an execution unit.

![A Common Data Bus broadcast reaches matching consumers](https://images.hxzhouh.com/blog-images/2026/11/37d38582e589b12965684bca5ef23d57.gif)

*Programmatically drawn teaching animation (Illustration). A broadcasts the value 6, and both consumers waiting for A capture it. A consumer waiting for B keeps waiting. Receiving a result does not guarantee immediate execution. Simplified from* [*Tomasulo's paper*](https://courses.grainger.illinois.edu/ece511/fa2005/papers/Tomasulo.1967.IBMJRD.pdf?ref=huizhou92.com)*; animation timing is illustrative.*

A later instruction can reuse the same register name while an earlier instruction still knows which result it is waiting for. The hardware distinguishes a program's limited set of register names from the different results being calculated. This is the central idea behind **register renaming**.

Renaming does not eliminate every wait. An instruction that genuinely needs an earlier result must still wait for it. Renaming removes false dependencies caused by reuse of register names; occupied hardware and data transfers can still cause delays.

Tomasulo analyzed an inner loop in his paper. Under the conditions he compared, an iteration took 17 clock cycles without the CDB and **11 cycles** with it. This was an analysis of a particular example, not a measured speedup for every program.

## A Limited Production Run, then the Microprocessor Era

Building and delivering the Model 91 remained an engineering and commercial challenge.

The Model 91 used IBM's ASLT (Advanced Solid Logic Technology) high-speed logic circuits, with a machine cycle of 60 nanoseconds. The design also had to address the speed difference between processor and memory. [IBM's functional characteristics manual](https://www.bitsavers.org/pdf/ibm/360/functional%5Fcharacteristics/GA22-6907-3%5F360%5F91%5FFunc%5FChar%5FNov71.pdf?ref=huizhou92.com) describes the machine.

CDC filed its private antitrust case against IBM in 1968, and the companies settled in 1973\. The available evidence does not establish the lawsuit as the reason the Model 91 stopped production. Only 15 machines were built, leaving it without a broad installed base.

The dynamic scheduling approach described in the paper later appeared in microprocessor designs.

During the 1990s, improvements in semiconductor manufacturing allowed microprocessors to contain more transistors. Designers explored how to extract more instruction-level parallelism and handle dependencies and delays only known at runtime. Hardware dynamic scheduling was one approach they adopted.

Robert Colwell's Intel P6 team also had to work with a limited register set and a complex instruction set when designing the **Pentium Pro**, introduced in 1995\. The x86 architecture then offered eight general-purpose registers.

P6 continued the use of dynamic scheduling and renaming. Its front end decoded complex x86 instructions into simpler micro-operations, which entered a 20-entry reservation station for dynamic dispatch. A **reorder buffer (ROB)** allowed micro-operations to execute out of order while retiring in program order. [David Papworth's account of P6](https://courses.grainger.illinois.edu/ece511/fa2005/papers/Papworth.1996.Micro.pdf?ref=huizhou92.com) describes this organization.

Later processors used other arrangements too. The MIPS R10000, for example, used a **physical register file (PRF)** to hold renamed results. Execution units read and wrote those registers directly. [The designer's paper](https://www.cs.princeton.edu/courses/archive/fall10/cos375/Yeager.1996.Micro.pdf?ref=huizhou92.com) explains the design.

Many modern high-performance processors still use dynamic renaming to remove false register dependencies and schedule instructions according to data readiness. Their schedulers, register files, and result-forwarding networks differ in implementation.

In 1997, the IEEE Computer Society and ACM awarded Robert Tomasulo the **Eckert–Mauchly Award** for his algorithm's contribution to out-of-order processor implementations.

Only 15 Model 91s were built. Its treatment of waiting operands, result broadcasts, and register renaming left later processor designers an approach they could continue developing.

### References

- R. M. Tomasulo, [*An Efficient Algorithm for Exploiting Multiple Arithmetic Units*](https://courses.grainger.illinois.edu/ece511/fa2005/papers/Tomasulo.1967.IBMJRD.pdf?ref=huizhou92.com), 1967
- James E. Thornton, [*Design of a Computer: The Control Data 6600*](https://archive.computerhistory.org/resources/text/CDC/cdc.6600.thornton.design%5Fof%5Fa%5Fcomputer%5Fthe%5Fcontrol%5Fdata%5F6600.1970.102630394.pdf?ref=huizhou92.com), 1970
- IBM, [*System/360 Model 91 Functional Characteristics*](https://www.bitsavers.org/pdf/ibm/360/functional%5Fcharacteristics/GA22-6907-3%5F360%5F91%5FFunc%5FChar%5FNov71.pdf?ref=huizhou92.com)
- A. Padegs, [*System/360 and Beyond*](https://www.ece.ucdavis.edu/~vojin/CLASSES/EEC272/S2005/Papers/Padegs-IBM360-sep81.pdf?ref=huizhou92.com), 1981
- David B. Papworth, [*Tuning the Pentium Pro Microarchitecture*](https://courses.grainger.illinois.edu/ece511/fa2005/papers/Papworth.1996.Micro.pdf?ref=huizhou92.com), 1996
- Kenneth C. Yeager, [*The MIPS R10000 Superscalar Microprocessor*](https://www.cs.princeton.edu/courses/archive/fall10/cos375/Yeager.1996.Micro.pdf?ref=huizhou92.com), 1996
- IEEE Computer Society, [Eckert–Mauchly Award recipients](https://www.computer.org/volunteering/awards/eckert-mauchly?ref=huizhou92.com)