Although it couldn't actually manipulate any pixels, the Geometry Engine introduced in 1981 was a breakthrough processor capable of carrying out many of the most critical mathematical functions used in graphics.
The Geometry Engine was an engineering marvel. The special-purpose chip was based on a four-component vector, floating-point processor for three of the most fundamental operations in computer graphics: matrix transformations, clipping, and mapping to output device coordinates. Developed by Jim Clark and Marc Hannah at Stanford University in 1981, it was the first dedicated vertex processor for what has become a commodity component in modern GPUs.
Clark founded Silicon Graphics Inc. (SGI) later the same year, and it became one of the most famous and influential graphics companies ever. SGI was acquired from bankruptcy by Rackable Solutions in 2009, and in 2016, Hewlett Packard Enterprise acquired Rackable/SGI. The deal ended the era of SGI – but not the legend.
While at Sanford University in early 1980, Clark came out with a paper on the nMOS semiconductor capability and its use in very-large scale integrated (VLSI) designs. He said, “The system is designed to perform three of the very common geometric functions of computer graphics. A single chip type is used in 12 slightly different configurations to accomplish 4 × 4 matrix multiplications; line, character, and polygon clipping; and scaling of the clipped results to display device coordinates. This chip is referred to as the Geometry Engine.”
The Geometry Engine was a four-component vector function unit that allowed simple operations on floating-point numbers. The instruction set architecture (ISA) is composed of four identical function units, each of which had an 8-bit characteristic and a 20-bit mantissa. The engine accomplished the operations with a very simple structure that consisted of an arithmetic logic unit (ALU), three registers, and a stack.
This basic unit could do parallel adds, subtracts, and other similar two-variable operations on either the mantissa or the characteristic. Because one of the registers could shift down and the other could shift up, the engine could also handle multiplies and divides at the rate of one multiply or divide step per micro-cycle.
The 12-chip system consisted of 1,344 copies of a single bit-slice layout that was composed of these five elements. Four pins on the chip were wired to tell the microcode which of the 12 functions it was supposed to do, according to its position in the subsystem organization.
Key to the design was the use of design techniques advocated by Carver Mead and Lynn Conway in the seminal Introduction to VLSI Systems. The book had a significant influence on the methodology used to arrive at the Geometry Engine’s architecture.
There are three geometric operations that almost every graphics system must be able to perform: transformation, clipping, and scaling. Figure 1 illustrates these three functions.
The architecture of the Geometry Engine is illustrated in Figures 1 and 2, reproduced from Clark’s published works. Each of the four function units at the bottom two-thirds of Figure 3 consists of two copies of a computing unit, a mantissa, and characteristic. The chip’s internal clock generator is in the top left corner, while a microprogram counter with push-down subroutine stack is at the top right. The upper third of the chip included the control store, which held the equivalent of 40 kB and contained all of the microcode to implement the instructions and floating-point computations.
Immediately after releasing his landmark paper in Lambda, a small group of semiconductor engineers –Clark, Charles Kuta, Kurt Akeley, David J. Brown, and Abbey Silverstone – founded Silicon Graphics Inc. They employed the Geometry System board in a workstation called the Integrated Raster Imaging System, IRIS, which combined the following components:
- A processor/memory board with the Motorola 68000 and 256 kB of RAM, which could be expanded to 2 MB. The 68000 microprocessor executed instructions in the on-board memory at 8 MHz. The memory was fully mapped and segmented for 16 processes. Additional memory was accessed over the Multibus at normal Multibus rates.
- A Geometry Subsystem, with Multibus interface FIFOs at the input and output of the Geometry System and from 10 to 12 copies of the Geometry Engine.
- A 1024 x 1024 Color Raster Subsystem, with high-performance hardware for polygon fill, vector drawing and arbitrary, variable-pitch characters. The hardware and firmware provide color and textured lines and polygons, character clipping, color mapping of up to 256 colors and selectable double- or single-buffered image planes.
- A 10-Mbps Ethernet interface board.
The Geometry Engine was also a breakthrough in size and performance. Matrox, one of the pioneering graphics add-in board (AIB) makers, having introduced their first PC graphics board in 1978, was the first company to offer a single 3D AIB, the SM 640 in 1987. Matrox had been building 2D graphics boards for the PC and adopted SGI’s Geometry Engine chip on a second layer mezzanine board to handle the 3D work.
But with the limited number of 3D applications for PCs, the product was a commercial flop. The migration of minicomputer and workstation applications to the PC took far longer than expected, but it lit up the imagination of all the AIB suppliers at the time.
In 1987, seeing the PC market slipping away from them due to clones, IBM introduced a proprietary operating system, OS2, and a new high-bandwidth AIB bus, the Micro Channel architecture (MCA). In 1991, SGI introduced the Micro Channel-based IrisVision, one of the first 3D accelerator cards available for the high-end PC market.
A few years later, IBM licensed both the graphics subsystem and the then-new IRIS Graphics Library (IRIS GL) API for their RS/6000 POWERstation line of POWER1-based workstations.
The Geometry System was a powerful computing system for graphics applications. It combined several useful geometric computing primitives in a custom VLSI system that was also scalable in nature. Within half a decade, the system was implemented on a single, half-million transistor integrated circuit, with a correspondingly reduced cost and increased speed.
SGI was conquered by the PC. But the legacy of the Geometry Engine has played a central role in improving graphics for games, scientific visualization, design, and VFX. Many of its fundamental features are found in hundreds of millions of modern GPUs in use today.
