Vector instructions, once a powerful performance innovation of supercomputing in the 1970s and 1980s became an obsolete technology in the 1990s. But like the mythical phoenix bird, vector instructions have arisen from the ashes. Here is the history of a technology that went from new to old then back to new.

But first, a few definitions. A vector instruction is an SIMD instruction, Single Instruction Multiple Data. A vector instruction refers to vector registers where multiple data resides. For example, a Cray-1’s vector register contained up to 64 64-bit double-precision floating point numbers. The Cray-1 had eight of these registers. Many operations, for example: add and multiply can be issued to add or multiply two vector registers and place the result in a third vector register.

Vectors Become New

In 1976 Cray Research and Seymour Cray created the Cray-1, the first commercially successful supercomputer with vector instructions. The first Cray-1 was delivered to Los Alamos National Laboratory. There had been other vector computers before: The University of Illinois’s ILLIAC IV, Texas Instruments Advanced Scientific Computer (ASC), and Control Data Corporation’s STAR-100. But none of these was a commercial success. With the Cray-1, vector technology became mainstream in the supercomputer world. Compilers were developed to automatically vectorize loops.

The Cray-1 did not have a cache. The vector registers were the computational “way stations” between memory and the functional units. The functional units computed the mathematical operations – for example, add and multiply.

The vector instructions made good sense. They improved performance, were simple, reduced instruction encoding, reduced the calculation of addresses, and reduced instruction cache misses. Here’s a simple example, adding two arrays together:

do i=1,n

C(i) = A(i) + B(i)

enddo

With a scalar CPU (Central Processing Unit), the loop looks like the following:

1. Calculate the address of A(i)
2. Calculate the address of B(i)
3. Load A(i) into a register
4. Load B(i) into a register
5. Add A(i) and B(i) and put the result into a register
6. Calculate the address of C(i)
7. Store the contents of the result register at C(i)
8. Increment i by 1
9. Compare if i>N
10. Jump to the top of the loop

Here’s what the loop looks like with vector instructions:

1. Calculate the address of A(i)
2. Calculate the address of B(i)
3. Load A(i:i+63) into a vector register
4. Load B(i:i+63) into a vector register
5. Add A(i:i+63) and B(i:i+63) into a vector register
6. Calculate the address of C(i)
7. Store the contents of the result vector register at C(i)Increment i by 64
8. Compare if i>N
9. Jump to the top of the loop

Note that the vector loop saves 3*63 instruction calculations, 2*63 load instructions, 63 store instructions, 63 compare instructions, and 63 jump instructions for every 64 iterations of the CPU loop.

Cray Research continued with the Cray-1S (1979), Cray-1M (1982) and the Cray-XMP (1982) and was highly successful in the 1980s. In the mid-1980s, Fujitsu, Hitachi, and Nippon Electric Corporation (NEC) also introduced vector supercomputers.

Vectors Become Old

A researcher at the Lawrence Livermore National Laboratory, Eugene D. Brooks, foretold the demise of the vector machines in 1990. His argument was simple: The Cray supercomputers were based on custom processors and he graphed the supercomputer’s peak FLOPS thru time.

Then he graphed the progress of the microprocessor’s peak Giga-FLOPS thru time. The lines crossed at ~1990 with the microprocessors pulling ahead of the supercomputer processors. He presented this at Supercomputer 1990 and entitled his talk, “Attack of the Killer Micros.”

Dr. Brooks defined: “A killer micro is a microprocessor-based machine that infringes on mini, mainframe, or supercomputer performance” and noted that “Nobody will survive the attack of the killer micros.” The microprocessors used scalar instructions, not vector instructions; so the rise of the microprocessors was the demise of the vector processors.

There were several other factors that were significant. The fall of the Berlin wall in 1989 decreased US government spending for supercomputers. Also, Intel Corporation and Advanced Micro Devices (AMD) were selling microprocessor in high volumes, allowing them to sustain large research and development efforts to improve their microprocessors, a situation the supercomputer companies could not match. Intel has been able to sustain Moore’s Law (it’s actually an observation) for 50 years. Moore’s Law, named after Intel founder Gordon Moore, states that the number of transistors in a processor will double every two years (1965).

Vectors Become New Again

The re-emergence of vector instructions started with the MMX instruction set (1997) which was added to the x86 architecture and the Intel Pentium processors. The instructions were SIMD, but the vectors were small (64-bits), few (8 registers) and the operations were integer, no floating point. A single instruction could then be applied to two 32-bit integers, four 16-bit integers, or eight 8-bit integers at once.

The next SIMD addition was the Streaming SIMD Extension (SSE) to the x86 architecture and the Pentium III (1999). The SSE instruction set added eight new 128-bit registers and floating point operations were added. In all, SSE added 70 new instructions. A single instruction could then be applied to two 64-bit double-precision floating point numbers, two 64-bit integers, four 32-bit integers, 8 16-bit short integers, or sixteen 8-bit bytes.

These instructions sets were soon enhanced: SSE2 (2001), SSE3 (2004), SSSE3 (2006), SSE4 (2006), and SSE5 (2007).

The next SIMD addition was the Advanced Vector Extensions (AVX) in 2008. The SSE registers were increased from 128 to 256 bits and renamed for AVX. The number of registers was increased from 8 to 16. Do we spot a trend here? AVX introduced a three-operand instruction format which allowed preservation of the input registers. For example, a two-operand operation is a=a+b, which destroys the “a” input register. A three-operand operation is c=a+b, which preserves the “a” register. Again enhancements followed, AVX2 (2013) which added integer 256-bit SIMD instructions and a floating point fused multiply-add.

Currently, the newest x86 supercomputer processor standard for vector instructions is AVX-512. The register length was expanded from 256 to 512 bits. The number of registers was expanded from 16 to 32. AVX-512 is supported in the Xeon Phi (Knights Landing) processor. These longer vectors support a peak of three TFLOPS in Knights Landing. Vectors were back!

Summary

One interesting way to look at the history of vector technology is to compare it to the dinosaurs, which arose in the Triassic Period, flourished in the Jurassic and Cretaceous Periods, and died out at the beginning of the Paleogene Period. This is a span of approximately 142 million years. Fortunately, the dinosaurs have not returned.

The vector processors arose in the 1970s and flourished until about 1990. The “Attack of the Killer Micros” correctly predicted their reign would end in the 1990s. But the vector processors started a comeback in 2000 with MMX and are flourishing in mainstream processors today. This is a span of approximately 50 years.

And the trends allow us a prediction of future mainstream processors; they will probably have more vector registers, more vector instructions, and the length of the vector registers will likely increase. You cannot keep a good idea down.

About the Author

Lynd Stringer is a Senior Program Analyst with Redline Performance Solutions, LLC. He has previously worked at the Lawrence Livermore National Laboratory (LLNL), Supercomputer Systems Inc. (SSI), Silicon Graphics Inc. (SGI), Intel, and The MathWorks. He has a Master’s Degree in Mathematics from the University of California at Berkeley.