Hubbry Logo
Cray-1Cray-1Main
Open search
Cray-1
Community hub
Cray-1
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Cray-1
Cray-1
Cray-1
View on Wikipedia
from Wikipedia

Cray-1
A Cray-1 on display at the Science Museum in London
Design
ManufacturerCray Research
DesignerSeymour Cray
Release date1975
Units soldOver 100
PriceUS$7.9 million in 1977 (equivalent to $41 million in 2024)
Casing
DimensionsHeight: 196 cm (77 in)[1]
Dia. (base): 263 cm (104 in)[1]
Dia. (columns): 145 cm (57 in)[1]
Weight5.5 tons (Cray-1A)
Power115 kW @ 208 V 400 Hz[1]
System
Front-endData General Eclipse
Operating systemCOS & UNICOS
CPU64-bit processor @ 80 MHz[1]
Memory8.39 Megabytes (up to 1 048 576 words)[1]
Storage303 Megabytes (DD19 Unit)[1]
FLOPS160 MFLOPS
SuccessorCray X-MP
3D rendering of a Cray-1 with two figures as scale

The Cray-1 was a supercomputer designed, manufactured and marketed by Cray Research. Announced in 1975, the first Cray-1 system was installed at Los Alamos National Laboratory in 1976. Eventually, eighty Cray-1s were sold, making it one of the most successful supercomputers in history. It is perhaps best known for its unique shape, a relatively small C-shaped cabinet with a ring of benches around the outside covering the power supplies and the cooling system.

The Cray-1 was the first supercomputer to successfully implement the vector processor design. These systems improve the performance of math operations by arranging memory and registers to quickly perform a single operation on a large set of data. Previous systems like the CDC STAR-100 and ASC had implemented these concepts but did so in a way that seriously limited their performance. The Cray-1 addressed these problems and produced a machine that ran several times faster than any similar design.

The Cray-1's architect was Seymour Cray; the chief engineer was Cray Research co-founder Lester Davis.[2] They would go on to design several new machines using the same basic concepts, and retained the performance crown into the 1990s.

2-views drawing of a Cray-1 with scaling

History

[edit]

From 1968 to 1972, Seymour Cray of Control Data Corporation (CDC) worked on the CDC 8600, the successor to his earlier CDC 6600 and CDC 7600 designs. The 8600 was essentially made up of four 7600s in a box with an additional special mode that allowed them to operate lock-step in a SIMD fashion.

Jim Thornton, formerly Cray's engineering partner on earlier designs, had started a more radical project known as the CDC STAR-100. Unlike the 8600's brute-force approach to performance, the STAR took an entirely different route. The main processor of the STAR had lower performance than the 7600, but added hardware and instructions to speed up particularly common supercomputer tasks.

By 1972, the 8600 had reached a dead end; the machine was so incredibly complex that it was impossible to get one working properly. Even a single faulty component would render the machine non-operational. Cray went to William Norris, Control Data's CEO, saying that a redesign from scratch was needed. At the time, the company was in serious financial trouble, and with the STAR in the pipeline as well, Norris could not invest the money.

As a result, Cray left CDC and started Cray Research very close to the CDC lab. In the back yard of the land he purchased in Chippewa Falls, Wisconsin, Cray and a group of former CDC employees started looking for ideas. At first, the concept of building another supercomputer seemed impossible, but after Cray Research's Chief Technology Officer travelled to Wall Street and found a lineup of investors willing to back Cray, all that was needed was a design.

For four years Cray Research designed its first computer.[3] In 1975 the 80 MHz Cray-1 was announced. The excitement was so high that a bidding war for the first machine broke out between Lawrence Livermore National Laboratory and Los Alamos National Laboratory, the latter eventually winning and receiving serial number 001 in 1976 for a six-month trial. The National Center for Atmospheric Research (NCAR) was the first official customer of Cray Research in 1977, paying US$8.86 million ($7.9 million plus $1 million for the disks) for serial number 3. The NCAR machine was decommissioned in 1989.[4] The company expected to sell perhaps a dozen of the machines, and set the selling price accordingly, but ultimately over 80 Cray-1s of all types were sold, priced from $5M to $8M. The machine made Seymour Cray a celebrity and his company a success, lasting until the supercomputer crash in the early 1990s.

Based on a recommendation by William Perry's study, the NSA purchased a Cray-1 for theoretical research in cryptanalysis. According to Budiansky, "Though standard histories of Cray Research would persist for decades in stating that the company's first customer was Los Alamos National Laboratory, in fact it was NSA..."[5]

The 160 MFLOPS Cray-1 was succeeded in 1982 by the 800 MFLOPS Cray X-MP, the first Cray multi-processing computer. In 1985, the very advanced Cray-2, capable of 1.9 GFLOPS peak performance, succeeded the first two models but met a somewhat limited commercial success because of certain problems at producing sustained performance in real-world applications. A more conservatively designed evolutionary successor of the Cray-1 and X-MP models was therefore made by the name Cray Y-MP and launched in 1988.

By comparison, the processor in a typical 2013 smart device, such as a Google Nexus 10 or HTC One, performs at roughly 1 GFLOPS,[6] while the A13 processor in a 2019 iPhone 11 performs at 154.9 GFLOPS,[7] a mark supercomputers succeeding the Cray-1 would not reach until 1994.

Background

[edit]
Main article: Vector processor § Supercomputers

Typical scientific workloads consist of reading in large data sets, transforming them in some way and then writing them back out again. Normally the transformations being applied are identical across all of the data points in the set. For instance, the program might add 5 to every number in a set of a million numbers.

In simple computers the program would loop over all million numbers, adding five, thereby executing a million instructions saying a = add b, c. Internally the computer solves this instruction in several steps. First it reads the instruction from memory and decodes it, then it collects any additional information it needs, in this case the numbers b and c, and then finally runs the operation and stores the results. The end result is that the computer requires tens or hundreds of millions of cycles to carry out these operations.

Vector machines

[edit]

In the STAR, new instructions essentially wrote the loops for the user. The user told the machine where in memory the list of numbers was stored, then fed in a single instruction a(1..1000000) = addv b(1..1000000), c(1..1000000). At first glance it appears the savings are limited; in this case the machine fetches and decodes only a single instruction instead of 1,000,000, thereby saving 1,000,000 fetches and decodes, perhaps one-fourth of the overall time.

The real savings are not so obvious. Internally, the CPU of the computer is built up from a number of separate parts dedicated to a single task, for instance, adding a number, or fetching from memory. Normally, as the instruction flows through the machine, only one part is active at any given time. This means that each sequential step of the entire process must complete before a result can be saved. The addition of an instruction pipeline changes this. In such machines the CPU will "look ahead" and begin fetching succeeding instructions while the current instruction is still being processed. In this assembly line fashion any one instruction still requires as long to complete, but as soon as it finishes executing, the next instruction is right behind it, with most of the steps required for its execution already completed.

Vector processors use this technique with one additional trick. Because the data layout is in a known format — a set of numbers arranged sequentially in memory — the pipelines can be tuned to improve the performance of fetches. On the receipt of a vector instruction, special hardware sets up the memory access for the arrays and stuffs the data into the processor as fast as possible.

CDC's approach in the STAR used what is today known as a memory-memory architecture. This referred to the way the machine gathered data. It set up its pipeline to read from and write to memory directly. This allowed the STAR to use vectors of length not limited by the length of registers, making it highly flexible. Unfortunately, the pipeline had to be very long in order to allow it to have enough instructions in flight to make up for the slow memory. That meant the machine incurred a high cost when switching from processing vectors to performing operations on non-vector operands. Additionally, the low scalar performance of the machine meant that after the switch had taken place and the machine was running scalar instructions, the performance was quite poor[citation needed]. The result was rather disappointing real-world performance, something that could, perhaps, have been forecast by Amdahl's law.

Cray's approach

[edit]

Cray studied the failure of the STAR and learned from it[citation needed]. He decided that in addition to fast vector processing, his design would also require excellent all-around scalar performance. That way when the machine switched modes, it would still provide superior performance. Additionally he noticed that the workloads could be dramatically improved in most cases through the use of registers.

Just as earlier machines had ignored the fact that most operations were being applied to many data points, the STAR ignored the fact that those same data points would be repeatedly operated on. Whereas the STAR would read and process the same memory five times to apply five vector operations on a set of data, it would be much faster to read the data into the CPU's registers once, and then apply the five operations. However, there were limitations with this approach. Registers were significantly more expensive in terms of circuitry, so only a limited number could be provided. This implied that Cray's design would have less flexibility in terms of vector sizes. Instead of reading any sized vector several times as in the STAR, the Cray-1 would have to read only a portion of the vector at a time, but it could then run several operations on that data prior to writing the results back to memory. Given typical workloads, Cray felt that the small cost incurred by being required to break large sequential memory accesses into segments was a cost well worth paying.

Since the typical vector operation would involve loading a small set of data into the vector registers and then running several operations on it, the vector system of the new design had its own separate pipeline. For instance, the multiplication and addition units were implemented as separate hardware, so the results of one could be internally pipelined into the next, the instruction decode having already been handled in the machine's main pipeline. Cray referred to this concept as chaining, as it allowed programmers to "chain together" several instructions and extract higher performance.

Performance

[edit]

In 1978, a team from the Argonne National Laboratory tested a variety of typical workloads on a Cray-1 as part of a proposal to purchase one for their use, replacing their IBM 370/195. They also planned on testing on the CDC STAR-100 and Burroughs Scientific Computer, but such tests, if they were performed, were not published. The tests were run on the Cray-1 at the National Center for Atmospheric Research (NCAR) in Boulder, Colorado. The only other Cray available at the time was the one at Los Alamos, but accessing this machine required Q clearance.[8]

The tests were reported in two ways. The first was a minimum conversion needed to get the program running without errors, but making no attempt to take advantage of the Cray's vectorization. The second included a moderate set of updates to the code, often unwinding loops so they could be vectorized. Generally, the minimal conversions ran roughly the same speed as the 370 to about 2 times its performance (mostly due to a larger exponent range on the Cray), but vectorization led to further increases between 2.5 and 10 times. In one example program, which performed an internal fast Fourier transform, performance improved from the IBM's 47 milliseconds to 3.[8]

Description

[edit]
Memory board, other side is the same - holds 4,096 64-bit words.

The new machine was the first Cray design to use integrated circuits (ICs). Although ICs had been available since the 1960s, it was only in the early 1970s that they reached the performance necessary for high-speed applications. The Cray-1 used only four different IC types, an emitter-coupled logic (ECL) dual 5-4 NOR gate (one 5-input, and one 4-input, each with differential output),[9] another slower MECL 10K 5-4 NOR gate used for address fanout, a 16×4-bit high speed (6 ns) static RAM (SRAM) used for registers and a 1,024×1-bit 48 ns SRAM used for the main memory. These integrated circuits were supplied by Fairchild Semiconductor and Motorola.[10] In all, the Cray-1 contained about 200,000 gates.

ICs were mounted on large five-layer printed circuit boards, with up to 144 ICs per board. Boards were then mounted back to back for cooling (see below) and placed in twenty-four 28-inch-high (710 mm) racks containing 72 double-boards. The typical module (distinct processing unit) required one or two boards. In all the machine contained 1,662 modules in 113 varieties.

Each cable between the modules was a twisted pair, cut to a specific length in order to guarantee the signals arrived at precisely the right time and minimize electrical reflection. Each signal produced by the ECL circuitry was a differential pair, so the signals were balanced. This tended to make the demand on the power supply more constant and reduce switching noise. The load on the power supply was so evenly balanced that Cray boasted that the power supply was unregulated. To the power supply, the entire computer system looked like a simple resistor.

The high-performance ECL circuitry generated considerable heat, and Cray's designers spent as much effort on the design of the refrigeration system as they did on the rest of the mechanical design. In this case, each circuit board was paired with a second, placed back to back with a sheet of copper between them. The copper sheet conducted heat to the edges of the cage, where liquid Freon running in stainless steel pipes drew it away to the cooling unit below the machine. The first Cray-1 was delayed six months due to problems in the cooling system; lubricant that is normally mixed with the Freon to keep the compressor running would leak through the seals and eventually coat the boards with oil until they shorted out. New welding techniques had to be used to properly seal the tubing.

In order to bring maximum speed out of the machine, the entire chassis was bent into a large C-shape. Speed-dependent portions of the system were placed on the "inside edge" of the chassis, where the wire-lengths were shorter. This allowed the cycle time to be decreased to 12.5 ns (80 MHz), not as fast as the 8 ns 8600 he had given up on, but fast enough to beat CDC 7600 and the STAR. NCAR estimated that the overall throughput on the system was 4.5 times that of the CDC 7600.[11]

The Cray-1 was built as a 64-bit system, a departure from the 7600/6600, which were 60-bit machines (a change was also planned for the 8600). Addressing was 24-bit, with a maximum of 1,048,576 64-bit words (1 megaword) of main memory, where each word also had eight parity bits for a total of 72 bits per word.[12] Memory was spread across 16 interleaved memory banks, each with a 50 ns cycle time, allowing up to four words to be read per cycle. Smaller configurations could have 0.25 or 0.5 megawords of main memory. Maximum aggregate memory bandwidth was 638 Mbit/s.[12]

The main register set consisted of eight 64-bit scalar (S) registers and eight 24-bit address (A) registers. These were backed by a set of sixty-four registers each for S and A temporary storage known as T and B respectively, which could not be seen by the functional units. The vector system added another eight 64-element by 64-bit vector (V) registers, as well as a vector length (VL) and vector mask (VM). Finally, the system also included a 64-bit real-time clock register and four 64-bit instruction buffers that held sixty-four 16-bit instructions each. The hardware was set up to allow the vector registers to be fed at one word per cycle, while the address and scalar registers required two cycles. In contrast, the entire 16-word instruction buffer could be filled in four cycles.

The Cray-1 had twelve pipelined functional units. The 24-bit address arithmetic was performed in an add unit and a multiply unit. The scalar portion of the system consisted of an add unit, a logical unit, a population count, a leading zero count unit and a shift unit. The vector portion consisted of add, logical and shift units. The floating point functional units were shared between the scalar and vector portions, and these consisted of add, multiply and reciprocal approximation units.

The system had limited parallelism. It could issue one instruction per clock cycle, for a theoretical performance of 80 MIPS, but with vector floating-point multiplication and addition occurring in parallel theoretical performance was 160[13] MFLOPS. (The reciprocal approximation unit could also operate in parallel, but did not deliver a true floating-point result - two additional multiplications were needed to achieve a full division.)

Since the machine was designed to operate on large data sets, the design also dedicated considerable circuitry to I/O. Earlier Cray designs at CDC had included separate computers dedicated to this task, but this was no longer needed. Instead the Cray-1 included four six-channel controllers, each of which was given access to main memory once every four cycles. The channels were 16 bits wide and included three control bits and four bits for error correction, so the maximum transfer speed was one word per 100 ns, or 500 thousand words per second for the entire machine.

The initial model, the Cray-1A, weighed 10,500 pounds (4,800 kg) including the Freon refrigeration system. Configured with 1 million words of main memory, the machine and its power supplies consumed about 115 kW of power;[10] cooling and storage likely more than doubled this figure.[citation needed] A Data General SuperNova S/200 minicomputer served as the maintenance control unit (MCU), which was used to feed the Cray Operating System into the system at boot time, to monitor the CPU during use, and optionally as a front-end computer. Most, if not all, Cray-1As were delivered using the follow-on Data General Eclipse as the MCU.

The reliability of the CRAY-1A was very low by today's standards. At the European Centre for Medium-Range Weather Forecasts, which was one of the first customers, the mean time between hardware faults was reported to be 96 hours in 1979.[14] Seymour Cray deliberately made design decisions that sacrificed reliability for speed, but improved his later designs after being questioned on this matter. Similarly, the Cray Operating System (COS) was fairly rudimentary, hardly tested and updated weekly or even daily in the early days.

Cray-1S

[edit]

The Cray-1S, announced in 1979, was an improved Cray-1 that supported a larger main memory of 1, 2 or 4 million words. The larger main memory was made possible through the use of 4,096 x 1-bit bipolar RAM ICs with a 25 ns access time.[15] The Data General minicomputers were optionally replaced with an in-house 16-bit design running at 80 MIPS. The I/O subsystem was separated from the main machine, connected to the main system via a 6 Mbit/s control channel and a 100 Mbit/s High Speed Data Channel. This separation made the 1S look like two "half Crays" separated by a few feet, which allowed the I/O system to be expanded as needed. Systems could be bought in a variety of configurations from the S/500 with no I/O and 0.5 million words of memory to the S/4400 with four I/O processors and 4 million words of memory.

Cray-1M

[edit]

The Cray-1M, announced in 1982, replaced the Cray-1S.[16] It had a faster 12 ns cycle time and used less expensive MOS RAM in the main memory. The 1M was supplied in only three versions, the M/1200 with 1 million words in 8 banks, or the M/2200 and M/4200 with 2 or 4 million words in 16 banks. All of these machines included two, three or four I/O processors, and the system added an optional second High Speed Data Channel. Users could add a Solid-state Storage Device with 8 to 32 million words of MOS RAM.

Software

[edit]

In 1978, the first standard software package for the Cray-1 was released, consisting of three main products:

The United States Department of Energy funded sites from Lawrence Livermore National Laboratory, Los Alamos Scientific Laboratory, Sandia National Laboratories and the National Science Foundation supercomputer centers (for high-energy physics) represented the second largest block with LLL's Cray Time Sharing System (CTSS). CTSS was written in a dynamic memory Fortran, first named LRLTRAN, which ran on CDC 7600s, renamed CVC (pronounced "Civic") when vectorization for the Cray-1 was added. Cray Research attempted to support these sites accordingly. These software choices had influences on later minisupercomputers, also known as "crayettes".

NCAR has its own operating system (NCAROS).

The National Security Agency developed its own operating system (Folklore) and language (IMP with ports of Cray Pascal and C and Fortran 90 later)[17]

Libraries started with Cray Research's own offerings and Netlib.

Other operating systems existed, but most languages tended to be Fortran or Fortran-based. Bell Laboratories, as proof of both portability concept and circuit design, moved the first C compiler to their Cray-1 (non-vectorizing). This act would later give CRI a six-month head start on the Cray-2 Unix port to ETA Systems' detriment, and Lucasfilm's first computer generated test film, The Adventures of André & Wally B..

Application software generally tends to be either classified (e.g. nuclear code, cryptanalytic code) or proprietary (e.g. petroleum reservoir modeling). This was because little software was shared between customers and university customers. The few exceptions were climatological and meteorological programs until the NSF responded to the Japanese Fifth Generation Computer Systems project and created its supercomputer centers. Even then, little code was shared.

Partly because Cray were interested in the publicity, they supported the development of Cray Blitz which won the fourth (1983) and fifth (1986) World Computer Chess Championship, as well as the 1983 and 1984 North American Computer Chess Championship. The program, Chess, that dominated in the 1970s ran on Control Data Corporation supercomputers.

Museums

[edit]

Cray-1s are on display at the following locations:

Other images of the Cray-1

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Cray-1

View on Grokipedia
from Grokipedia
The Cray-1 was a groundbreaking vector supercomputer developed by Cray Research, Inc., founded by engineer Seymour Cray in 1972, and first delivered to customers in 1976. It featured a distinctive C-shaped design measuring approximately 8.5 feet wide and 6.5 feet high, with over 60 miles of hand-wired circuitry optimized for high-speed data processing, achieving peak performance of up to 160 million floating-point operations per second (MFLOPS). The machine utilized a 12.5-nanosecond clock cycle, eight 64-element vector registers, and up to 1 million 64-bit words (8 megabytes) of high-speed semiconductor memory, making it ten times faster than its contemporaries through innovative vector processing capabilities that allowed parallel handling of numerical computations. Priced at approximately $8.8 million per unit (equivalent to about $45 million in 2024) and consuming 115 kilowatts of power, the Cray-1 was primarily deployed for complex scientific simulations in fields such as weather forecasting, nuclear weapons modeling, and aerospace engineering, with over 60 units produced between 1976 and 1982. Its introduction marked the birth of the modern supercomputing industry, establishing Cray Research as a dominant force and influencing subsequent designs by emphasizing simplicity, speed, and reliability in high-performance computing.

Development and History

Origins and Design Goals

In 1972, left (CDC), where he had been a key designer of influential supercomputers like the and 7600, to found Cray Research, Inc. in . His departure was driven by frustrations with CDC's shifting priorities toward commercial products and limited funding for ambitious research into faster scientific computing systems, allowing him to pursue innovative designs without broader corporate interference. Accompanied by a small team of six engineers from CDC, Cray aimed to target a for high-performance computers dedicated to scientific applications. The Cray-1 project was motivated by the need to advance computational capabilities for complex scientific simulations, including weather modeling and nuclear research, where large-scale data-parallel processing was essential. Key design goals centered on achieving a peak performance of 160 MFLOPS through an emphasis on vector processing, which enabled efficient handling of array-based operations common in such tasks, while prioritizing simplicity in architecture to ensure reliability and ease of programming. This approach contrasted with contemporaries like the , which relied on complex instruction sets and for parallelism; the Cray-1 sought shorter, faster pipelines using integrated circuits to deliver superior scalar and vector throughput without such overhead. Securing initial funding proved challenging amid economic uncertainty in the early , with Cray Research relying on a $250,000 grant from CDC and additional , including Cray's personal assets, to cover the estimated development costs. These resources supported a focused effort on vector-enabled performance gains, setting the stage for the Cray-1 to outperform existing systems in targeted scientific workloads.

Development Timeline

Cray Research was founded in 1972 by in , where an initial team of approximately 30 engineers, many drawn from , assembled to pursue advanced computer designs. Development of the Cray-1 began shortly thereafter, with Cray establishing a dedicated in September 1972 to focus on the project. By 1974, the prototype design had advanced to the stage where initial silicon chips for the vector registers were tested, marking a key step in realizing the machine's vector processing architecture. In 1975, committed to purchasing the first Cray-1 unit for $8.8 million, providing the financial backing necessary to transition from prototyping to production. This order, following consultations between Los Alamos and Cray on the design, enabled the company to finalize . The Cray-1 was formally announced that year, highlighting its potential for high-speed scientific computing. The first Cray-1 was delivered to Los Alamos on March 4, 1976, as serial number 001 for a six-month evaluation trial. Through mid-1976, the system underwent intensive debugging and optimization to ensure reliability and performance in real-world applications. A significant challenge during development involved the iterative refinement of the Freon-based cooling system, designed to dissipate the machine's substantial 115 kW power draw while maintaining component integrity.

Initial Production and Deployment

The Cray-1 supercomputers were manufactured at Cray Research's facility in , with initial production commencing in 1976. The first unit, serial number 1, was delivered to in March 1976 for a six-month evaluation period at no cost, marking the transition from prototype to operational deployment. Following the evaluation, the became the first paying customer, installing serial number 3 in July 1977 at a cost of $8.86 million, which included $7.9 million for the system and nearly $1 million for . By September 1977, approximately twelve Cray-1 units had been installed worldwide, with early adopters including , which received its first system in 1978. Deployment of each Cray-1 demanded specialized , including a dedicated 115 kW —equivalent to powering about ten average homes—and a custom Freon-based refrigeration cooling system to dissipate the immense heat from its densely packed circuitry, often requiring isolated computer rooms. By the end of 1978, Cray Research had at least seventeen Cray-1 systems operational in the field, fueling the company's early commercial success. Sales were constrained by international export controls under the Coordinating Committee for Multilateral Export Controls (CoCom), which restricted shipments of advanced computing technology to non-Communist allied nations to prevent proliferation of strategic capabilities.

Technical Background

Vector Processing Fundamentals

Vector processing refers to a computational paradigm in which a processor executes instructions that operate simultaneously on multiple elements of a data array, known as a vector, rather than processing individual scalar values one at a time. This approach contrasts with scalar processing, where operations are performed sequentially on single data items, enabling vector processors to achieve higher throughput for data-parallel workloads by leveraging hardware pipelines that apply the same operation across an entire vector in a single instruction. In essence, vector instructions such as those for addition or multiplication treat arrays as atomic units, reducing the overhead of loop iterations and control flow in software. The conceptual foundations of vector processing emerged in the early 1960s, with pioneering efforts like the project at , which aimed to accelerate mathematical computations through parallel array operations. This initiative sought to dramatically enhance performance in numerical tasks by processing vectors in parallel, laying groundwork for subsequent designs despite not reaching full production. Vector processing proved particularly advantageous in scientific computing, where applications often involve repetitive operations over large arrays, such as simulations in physics or ; by vectorizing loops that iterate over these arrays, processors could exploit data-level parallelism to achieve speedups of 10 to 100 times compared to scalar equivalents for suitable codes. Core vector operations include fundamental arithmetic instructions like vector addition (VADD), which adds corresponding elements from two source vectors to produce a result vector, and (VMUL), which multiplies elements pairwise. These instructions are typically pipelined, allowing continuous data flow through functional units to process long vectors element by element without stalling for each operation. To handle dependent operations efficiently, vector chaining enables the output of one vector unit—such as the result of a VMUL—to be forwarded directly as input to another unit, like a subsequent VADD, overlapping and minimizing idle time between instructions. Early vector designs faced significant limitations, particularly memory bandwidth bottlenecks, as loading and storing large vectors from main could not keep pace with the high-speed arithmetic pipelines, leading to underutilization of processing units. These issues were mitigated through techniques like , which reduced dependency on immediate access by allowing intermediate results to bypass , and register-based architectures that staged vectors in fast on-chip registers to decouple from slower hierarchies. Such strategies emphasized keeping in registers during processing, thereby alleviating bandwidth constraints and improving overall efficiency for array-oriented computations.

Seymour Cray's Approach

Seymour Cray's design philosophy for the Cray-1 emphasized simplicity and low latency to achieve high performance, drawing from lessons learned in earlier machines like the and 7600. He opted for short pipelines operating on 64-bit words across 12 functional units, which minimized delays in scalar and vector operations compared to longer pipelines in prior systems. This approach reduced overall latency, enabling efficient handling of both short and long vectors without excessive startup overhead. To further enhance speed, Cray avoided complex implementations in favor of direct hardware logic using simple gates, ensuring balanced dynamic loads across the system and prioritizing raw clock rates over interpretive overhead. A key innovation was the introduction of eight vector registers, each capable of holding 64 elements of 64-bit data, which facilitated rapid data access and manipulation in a register-to-register architecture. This design allowed for seamless integration with vector processing, where operands were fetched and results stored efficiently within the registers, outperforming memory-to-memory vector machines of the era. Complementing this, functional unit chaining enabled interim results from one unit to be immediately fed as inputs to another, effectively hiding latency and sustaining high throughput during chained vector operations. Cray's risk-taking manifested in a deliberately simplified instruction set, comprising 128 basic instructions encoded in 16-bit words, which traded versatility for maximized clock speed and reduced hardware complexity. This minimalist approach reflected his belief in focusing resources on core computational efficiency rather than broad functionality, allowing the Cray-1 to achieve superior performance in targeted scientific workloads. In contrast to the CDC 7600's mechanism for handling scalar dependencies, Cray shifted emphasis to a vector-centric model with integrated scalar support, streamlining the architecture and eliminating much of the prior complexity while delivering roughly twice the scalar performance and significant vector gains.

Projected Performance Characteristics

The Cray-1 featured a scalar processor clocked at 80 MHz, corresponding to a 12.5-nanosecond cycle time. This design enabled a theoretical peak performance of 80 million floating-point operations per second (MFLOPS) without vector chaining, rising to 160 MFLOPS for vector multiply-add operations when chaining techniques were employed. The system supported up to 1 million 64-bit words (8 megabytes) of main memory, with a maximum data streaming rate from the I/O subsystem of approximately 4 megabytes per second. Overall power consumption reached 115 kilowatts for a fully configured machine. Independent benchmarks demonstrated sustained performance of around 138 MFLOPS on floating-point workloads, with Linpack results typically achieving 80-100 MFLOPS. On vectorized tasks, the Cray-1 delivered approximately 4.5 to 5 times the throughput of the , depending on vector length.

Architecture and Design

Processor and Pipeline Details

The Cray-1's (CPU) is organized into four quadrants arranged around the central , with each quadrant housing three specialized functional units for a total of 12 pipelined functional units. These units are categorized into function units for indexing and looping, scalar units for general-purpose operations, vector units for bitwise and arithmetic vector processing, and floating-point units for high-precision computations. All functional units operate on 64-bit paths, enabling simultaneous execution of multiple independent operations to achieve high throughput in both scalar and vector modes. The register file supports vector processing through eight 64-element vector registers (V0 through V7), each element being 64 bits wide, allowing operations on arrays of up to 64 data items without explicit looping. Complementing these are eight 64-bit scalar registers (S0 through S7) for non-vector operations and eight 24-bit address registers (A0 through A7) dedicated to memory addressing, loop control, and indexing. To enhance performance and reduce memory accesses, each functional unit maintains local storage: 64 intermediate 64-bit scalar registers (T0 through T63) and 64 intermediate 24-bit address registers (B0 through B63), which act as a fast backup layer for frequently used values. All 12 functional units are deeply pipelined to sustain one result per clock cycle once initiated, with pipeline depths varying by unit: for example, the floating-point has 6 stages, the multiplier 7 stages, and the reciprocal approximation unit 14 stages. A key innovation is , which permits the output of one functional unit to be directly routed to the input of another without completing the full pipeline, allowing up to six floating-point operations to execute concurrently across chained units such as multiply-add sequences. This mechanism significantly boosts effective for vector workloads by overlapping computation phases. Instructions are formatted as variable-length sequences of 16-bit parcels packed into 64-bit words, with most arithmetic and logical operations encoded in a single parcel (over 100 opcodes total), while memory references and branches require two or more parcels aligned on 16-bit boundaries. The control section fetches instructions from the main MOS memory (up to 1 megaword capacity) into four dedicated 64-parcel buffers at a rate of up to four parcels per cycle, driven by an 80 MHz clock (12.5 ns period) that synchronizes the entire CPU. This buffered prefetch ensures continuous instruction supply, with initial fill times of about 10 cycles followed by sustained decoding at one parcel per cycle for vector chains.

Memory Hierarchy

The Cray-1's centered on a high-bandwidth main system without a traditional cache, relying instead on extensive register files to minimize latency for computational operations. Main consisted of storage using MOS chips arranged in a 16-bank configuration for interleaving, with a capacity of up to 1 million 64-bit words (8 MB). Each word was 72 bits wide, comprising 64 data bits and 8 ECC bits for single-error correction and double-error detection, ensuring reliable data storage in the high-speed environment. The 16-way interleaving allowed sequential accesses to sustain high throughput, achieving a theoretical peak bandwidth of 320 million 64-bit words per second (approximately 2.56 GB/s), though practical sustained rates to registers were 80 million words per second due to pipelining and access patterns. Dedicated vector load and store units facilitated efficient data transfer for vector operations, capable of handling up to 6 chained loads or stores per instruction to overlap memory accesses with computation and maintain flow. These units interfaced directly with the 8 vector registers (each holding 64 64-bit elements), serving as a fast buffer layer in the to reduce main contention during long vector operations. The lack of a cache was intentional, as the register-based approach and design provided sufficient locality and bandwidth for the target workloads in scientific computing. Peripheral storage and I/O formed the lower levels of the , with interfaces managed by front-end minicomputers to handle tape drives, disks, and other devices. A small 16-word solid-state buffer supported I/O transfers, acting as an intermediary to decouple the CPU from slower peripheral speeds. Optional devices (SSDs) could be added as staging memory for faster data movement between and main memory for large datasets. These SSDs used similar to main memory but were accessed via I/O channels at rates up to 100 MB/s.

Physical Structure and Cooling

The Cray-1 employed a distinctive C-shaped cabinet to optimize and accessibility, standing 6.5 feet (2 meters) tall with a base approximately 9 feet (2.7 meters) in diameter and a central column 4.5 feet (1.4 meters) across, resulting in a compact of about 70 square feet (6.5 square meters). This configuration limited the maximum interconnect wire length to under 4 feet (1.2 meters), reducing propagation delays in the high-speed circuitry. The mainframe weighed 5.25 tons (4.76 metric tons) and featured an aluminum frame with 12 wedge-shaped columns arranged in a cylindrical , facilitating modular assembly and service. Surrounding the base was a ring of benches covered in bent panels upholstered with colorful vinyl, concealing the power supplies while providing a functional seating area. Internally, the system comprised roughly 200,000 (ECL) integrated circuits—primarily 5-input NAND gates—mounted on 1,662 plug-in modules, each a 6-by-8-inch (15-by-20 cm) five-layer with up to 144 chips in a 12-by-12 . These modules connected via a custom using 67 miles (108 km) of 120-ohm twisted-pair wiring terminated at 96-pin connectors, enabling dense integration without excessive signal skew. The boards sandwiched 0.08-inch-thick (2 mm) copper plates serving as both ground planes and heat spreaders, with components fabricated on C10 glass-epoxy substrates featuring 7-mil (0.18 mm) traces. This architecture supported easy , as modules slid horizontally into the aluminum columns spaced 0.4 inches (10 mm) apart, allowing technicians to access and replace units without disrupting the entire system. The high density of these ECL chips, each dissipating around 60 mW, contributed to substantial thermal output from the vector processing units. Thermal management relied on a closed-loop Freon-22 recirculating about 40 gallons (151 liters) per minute to handle the heat dissipation of approximately 115 kW (393,000 Btu per hour), keeping chip die temperatures below 65°C (149°F) and case temperatures around 54°C (129°F). Within each module, heat conducted from the silicon dies through ceramic flatpack packages to the copper cold plate and then to vertical aluminum cold bars—0.5 inches (13 mm) thick—via direct contact. tubes embedded in these bars carried the chilled (at 18.5°C or 65°F) in a counterflow arrangement, dissipating heat without module-level fans and minimizing acoustic . The base-mounted refrigeration unit exchanged this heat with facility (requiring 20 gallons per minute at 3 psi drop), while the overall ensured uniform cooling across the 24 . Power consumption reached 115 kW at 208 V, 400 Hz for a fully configured , reflecting the demands of sustaining such dense, high-performance .

Variants and Upgrades

Cray-1S Enhancements

The Cray-1S, introduced in , served as an upgraded variant of the original Cray-1 , emphasizing expanded and enhanced (I/O) capabilities to address limitations in handling larger datasets and data-intensive workloads in scientific applications. A key enhancement was the expansion of maximum main capacity to 4 million 64-bit words (with 8 error-correction bits per word), a quadrupling from the Cray-1's 1 million-word limit, enabling more efficient processing of complex simulations without excessive reliance on external storage. This increase supported up to 1,152 modules, improving overall system availability to 98% with mean time between interruptions exceeding 100 hours. The Cray-1S also featured a new I/O subsystem with 2 to 4 dedicated I/O processors and buffer ranging from 1 to 8 million words, delivering throughput exceeding 800 Mbits/s via streaming channels—substantially higher than the original Cray-1's I/O performance—and facilitating faster data transfer for applications like (CFD). Models such as the S/1200 and higher incorporated this subsystem, with 12 I/O channels for peripheral connectivity. Design modifications contributed to a reduced of less than 70 square feet, achieved through more efficient vectorized processor boards and a modular layout separating the CPU/ section from the I/O components, while retaining the liquid-cooled, C-shaped structure for thermal management. The CPU maintained the original's 80 MHz clock speed (12.5 ns cycle) and eight 64-element vector registers but benefited from 230,000 logic gates for refined processing. These upgrades yielded a sustained performance of 138 MFLOPS (with bursts up to 250 MFLOPS), offering roughly a 20% improvement in floating-point operations over typical sustained rates, particularly in vector-heavy tasks. Targeted at existing owners, the Cray-1S supported field upgrades to higher memory and I/O configurations, extending the lifespan of early installations without requiring complete system replacement. A limited number of units were produced, focusing on cost-effective enhancements that lowered the per-unit price to around $7 million.

Cray-1M Modifications

The Cray-1M, introduced in 1982 as a successor to the Cray-1S, incorporated key modifications aimed at reducing system costs while preserving the core computational capabilities of the Cray-1 series. The primary adaptation was the use of less expensive metal-oxide-semiconductor (MOS) RAM in the main memory, which lowered the overall price tag without significantly impacting the main processor performance. This change made the Cray-1M more affordable for organizations seeking on a , though it resulted in marginally slower memory access times compared to bipolar-based systems. Retaining the single-processor architecture of earlier Cray-1 models, the Cray-1M operated at an improved ~83 MHz clock speed (12 ns cycle) and supported up to 32 MB (4 million 64-bit words) of main memory. Optional solid-state disk (SSD) storage was available to enhance data throughput for demanding applications, and the system included the vector processing features, such as 64-bit vector mask registers, inherited from the original design. These adaptations allowed the Cray-1M to handle scientific workloads similar to its predecessors, but with a focus on economical deployment rather than peak speed enhancements. The Cray-1M's design emphasized practicality for parallel-oriented tasks like seismic modeling, where custom software could be developed to optimize vector operations across workloads, though its single-CPU configuration limited inherent . Due to the niche appeal of these modifications and the rapid evolution toward more advanced systems like the , only a very small number of units (fewer than 10) were produced, which were often used for internal development at Cray Research, including work on subsequent projects. The integration of MOS introduced added complexity in the subsystem, potentially contributing to elevated needs and reliability challenges in operational environments.

Production and Deployment Differences

The original Cray-1 was hand-built by teams of technicians at Cray Research facilities in , involving meticulous hand-soldering of approximately 200,000 integrated circuits and miles of wiring arranged in a distinctive C-shaped to minimize signal propagation delays. Approximately 80 units were produced for the Cray-1 family overall between 1976 and 1982, with the base model forming the majority, reflecting the labor-intensive manufacturing process that limited output despite high demand from scientific and defense sectors. International sales extended to the , where systems were installed at sites like the European Centre for Medium-Range Forecasts, and to , with production supported under licensing agreements to facilitate local integration and support. In contrast, the Cray-1S variant benefited from refined techniques, including improved processes and modular components, which shortened build times to about 6 months per unit and reduced overall costs by optimizing material use and labor efficiency. This enabled production of a limited number of Cray-1S systems, promoting broader deployment in academic, , and industrial applications beyond the initial U.S.-centric focus of the original model. The lower , starting around $7 million compared to the original's $8-10 million, further accelerated adoption by international customers and smaller organizations. The Cray-1M, introduced in as a cost-optimized variant using MOS RAM for main memory, was produced in very small numbers due to its increased design complexity and niche focus on high-security environments. These systems were primarily deployed at U.S. Department of Defense sites, including the (NSA), where enhanced memory capacity and faster cycle times supported classified simulations and cryptography tasks without the broader market appeal of prior variants. Overall, the Cray-1 family culminated in approximately 80 units across all variants, with production ceasing in 1982 as the more advanced succeeded it, marking the transition to multi-processor supercomputing architectures.

Software Support

Operating Systems

The (COS), released in 1976, served as the primary operating system for the Cray-1 supercomputer. It provided capabilities, managing job submission, execution, and output staging through a front-end such as the PDP-11, which handled user interactions and peripheral I/O to isolate the Cray-1's compute resources. COS coordinated job scheduling by queuing requests on and dynamically allocating resources, rolling out inactive jobs to accommodate higher-priority or resource-intensive tasks. Key features of COS included multiprogramming support for up to 63 concurrent jobs, enabling efficient utilization of the Cray-1's vector processing units across multiple batch workloads. The Cray-1 lacked dedicated (MMU) hardware for full virtualization, relying instead on software-enforced protection via per-job base and limit registers to isolate memory regions and prevent unauthorized access. By 1980, the Cray Time Sharing System (CTSS) further advanced this capability, adding Unix-like command interfaces for remote terminal sessions and supporting up to 64 simultaneous users while building on COS's batch foundation for . CTSS emphasized decentralized control, priority-based scheduling, and system recovery features to facilitate collaborative scientific environments at sites like .

Compilers and Programming Tools

The Cray Fortran Compiler (CFT), introduced in 1976 alongside the initial (COS), served as the cornerstone of programming support for the Cray-1, enabling of standard code to leverage the system's vector registers and pipelines. Designed for ANSI 1966 Fortran IV, the CFT analyzed to identify vectorizable innermost DO loops, generating machine instructions that processed arrays in 64-element segments without requiring nonstandard pragmas or manual modifications. This approach allowed existing scientific programs to benefit from the Cray-1's , with the compiler handling scalar-to-vector conversions and basic optimizations like to reduce pipeline delays. Key optimizations in the CFT focused on enhancing vector throughput, including loop unrolling to amortize startup costs over longer operations and dependence analysis to facilitate chaining—where the output of one vector functional unit directly feeds into another, sustaining peak pipeline rates. For applications needing finer control, the Cray Assembly Language (CAL) provided a low-level interface, featuring a macro assembler for symbolic encoding of the Cray-1's 128 scalar and vector operation codes, enabling programmers to tune register usage and instruction sequences explicitly. Support for additional languages emerged later; by 1978, Pascal implementations were available on the Cray-1, allowing structured programming for non-Fortran tasks. Limited C support followed through ported compilers, though Fortran remained dominant for high-performance computing. Development tools complemented these compilers, including the Cray Debugger (CDB) for inspecting and modifying executing programs under COS, supporting breakpoints, variable examination, and tracebacks for both scalar and vector code. Performance analysis was aided by utilities that profiled instruction mix, vector lengths, and chain utilization, helping developers identify bottlenecks in vectorization efficiency. The Cray mathematical library offered pre-optimized routines for linear algebra operations, such as matrix multiplication and eigenvalue solvers, implemented with vector instructions to achieve high throughput on common scientific workloads. These elements collectively enabled sustained performance approaching 80% of theoretical peak on well-vectorized codes, as demonstrated in benchmarks like LINPACK. The CFT's innovations in and dependence handling profoundly influenced design, establishing techniques now integral to SIMD optimizations in modern processors like those from and . By prioritizing seamless exploitation of vector hardware, the Cray-1 tools set a benchmark for balancing and performance in supercomputing software ecosystems.

Legacy and Impact

Key Installations and Applications

The Cray-1 supercomputer was first installed at Los Alamos National Laboratory in March 1976, where it was primarily used for nuclear weapons simulations, enabling complex modeling of nuclear reactions without physical detonations. This inaugural deployment marked the beginning of its role in high-stakes scientific computing at U.S. Department of Energy facilities, with Los Alamos eventually operating multiple units for advanced hydrodynamic and plasma physics calculations. Subsequent installations expanded to key research centers, including the (NCAR) in , in 1977, supporting atmospheric modeling and weather prediction efforts that benefited from the system's vector processing capabilities. By 1981, the Exxon Production Research Center in , , received a Cray-1, applying it to oil exploration tasks such as 3D seismic data processing to map subsurface structures more efficiently. , including , integrated Cray-1 systems in the late 1970s for aerodynamics research, leveraging the machine for early (CFD) simulations in aircraft design. These installations facilitated notable achievements across domains. At NCAR, weather prediction models executed up to 10 times faster than on prior systems like the , accelerating global climate simulations and storm forecasting. In nuclear applications at Los Alamos, the Cray-1 enabled detailed 3D simulations of weapon performance, contributing to . NASA's use advanced CFD for aircraft aerodynamics, supporting designs like the by resolving complex airflow patterns that reduced reliance on testing. Industry users, such as Exxon, processed vast seismic datasets to enhance reservoir modeling, with the system's speed enabling real-time analysis of geophysical surveys. The user base skewed heavily toward government laboratories, which accounted for the majority of installations and utilization in the U.S., while industry sectors like energy exploration represented a growing but smaller share, focusing on commercial applications such as seismic processing. By the mid-1980s, the cumulative operational impact of these systems had supported millions of compute hours in scientific workloads, underscoring their foundational role in vector-based .

Influence on Supercomputing Evolution

The Cray-1's vector processing architecture became a cornerstone of supercomputing design, marking the first commercially successful implementation of vector instructions that enabled efficient handling of large-scale numerical computations. This innovation directly influenced successors within Research, such as the introduced in 1982, which built upon the Cray-1's vector foundation by adding shared-memory with up to four processors to enhance while maintaining high-speed vector operations. The design's emphasis on pipelined vector units and large register files also inspired international competitors, notably Japan's VP series launched in 1982, which adopted similar vector pipeline architectures and dynamically reconfigurable vector registers to achieve peak performances rivaling the , such as 570 MFLOPS on the VP-200. By demonstrating the viability of dedicated high-performance hardware, the Cray-1 catalyzed the establishment of a dedicated supercomputing industry, propelling Cray Research to dominate approximately 67% of the global market for large-scale systems by the mid-1980s. This market leadership was underscored by rapid revenue growth, reaching $101 million in 1981 as demand surged from scientific and sectors seeking unprecedented computational power. The system's success shifted industry focus toward specialized vector machines optimized for scientific workloads, fostering a competitive ecosystem that included both U.S. and Japanese firms. On a broader scale, the Cray-1 transformed scientific computing paradigms by enabling breakthroughs in simulations for applications like and , thereby expanding the boundaries of what was computationally feasible and inspiring sustained investment in high-performance systems. However, its exorbitant price—typically $7 to $8 million per installation—restricted to labs and centers, highlighting limitations in and scalability for the vector model. These constraints ultimately paved the way for massively parallel processing (MPP) architectures in the , as vendors like transitioned to systems such as the T3D in 1993, prioritizing clusters of commodity processors for improved cost-performance ratios over proprietary vector designs.

Preservation and Current Status

The Cray-1 has been preserved through dedicated efforts at various museums and institutions, ensuring its iconic design and historical significance remain accessible. The in , exhibits a Cray-1 model, highlighting its role in supercomputing innovation through static displays and educational programming. Similarly, the Chippewa Falls Museum of Industry and Technology in —located in the birthplace of Research—houses the original first production unit (serial number 001), which serves as a centerpiece for exhibits on local computing heritage. Other notable sites include the Bradbury Science Museum at in , which displays a unit originally installed there in 1977, and the at , featuring a Cray-1 tied to early cryptographic applications. In Europe, the Collection in the holds a complete Cray-1A (serial number 11), acquired for its engineering and computational history. Following the closure of the Living Computers: Museum + Labs in in 2020 and its permanent closure in 2024, its functional Cray-1 (serial number 12) and related artifacts were acquired by the Mimms Museum of Technology and Art in , where they now contribute to interactive technology exhibits. Restoration projects have extended the lifespan of surviving units, often led by institutions and dedicated enthusiasts. The Musée Bolo at the in is actively restoring multiple Cray systems, including a Cray-1, involving meticulous replacement of original foam insulation, leatherette upholstery, plexiglass panels, and metal components to maintain authenticity while addressing decades of wear. Independent efforts, such as the ongoing Cray-1 revival project by software engineer Chris Fenton, focus on reverse-engineering and rehabilitating a decommissioned Cray-1A unit through from original disks and recreation of legacy software environments. At the University of Wisconsin-Eau Claire, a 2025 student-led initiative in collaboration with (the modern steward of 's legacy) documents and preserves Cray-1 artifacts, drawing on alumni insights to catalog wiring, cooling systems, and operational manuals for future educational use. As of 2025, approximately 17 Cray-1 units are known to survive worldwide, primarily in non-operational states for display in historical exhibits that demonstrate the evolution of . While no units perform active scientific computations today, restored examples occasionally run demonstrations of legacy code to illustrate vector processing capabilities, as seen in past operations at the now-closed Living Computers Museum. Preservation faces significant challenges, including the scarcity of replacement parts for the machine's custom integrated circuits and wiring—over 60 miles per unit—which are no longer manufactured. The original Freon-based liquid cooling system, reliant on chlorofluorocarbons phased out under international environmental regulations in the , poses additional hurdles; modern adaptations often require custom refrigeration solutions to avoid lubricant contamination issues that historically delayed early deployments, complicating full functionality without compromising the design.

References

  1. https://www.hpe.com/us/en/compute/hpc/cray.html
  2. https://www.computerhistory.org/revolution/supercomputers/10/7
  3. https://cray-history.net/cray-history-front/fom-home/fom-cray-1/
  4. https://www.cisl.ucar.edu/ncar-supercomputing-history/c1
  5. https://americanhistory.si.edu/comphist/cray.htm
  6. https://pages.cs.wisc.edu/~markhill/restricted/cacm78_cray1.pdf
  7. https://www.nsa.gov/portals/75/documents/news-features/declassified-documents/history-today-articles/10%202018/05OCT2018%20SEYMOUR%20CRAY%20and%20NSA.pdf?ver=P3xsKeHprvcBBChHKi77Gw%3D%3D
  8. https://archive.nytimes.com/www.nytimes.com/library/cyber/week/1006cray.html
  9. https://www.sec.gov/Archives/edgar/data/949158/000089102005000085/v06093e10vk.htm
  10. https://www.designnews.com/motion-control/the-ultimate-team-player
  11. https://www.edn.com/cray-1-super-computer-the-power-supply/
  12. http://www.cis.usouthal.edu/faculty/daigle/project1/1975cray.htm
  13. https://www.computinghistory.org.uk/det/8605/Cray-Research-delivers-the-first-Cray-1A/
  14. https://www.lanl.gov/media/publications/national-security-science/1220-computing-on-the-mesa
  15. https://cray-history.net/wp-content/uploads/2021/07/Cray-1S.pdf
  16. https://www.llnl.gov/purpose/history/1980s
  17. https://www.hpcwire.com/2018/11/27/first-cray-1-on-display-at-sc18/
  18. https://www.filibeto.org/aduritz/supercomputing/cray/cray_faq.html
  19. https://www.princeton.edu/~ota/disk3/1979/7918/791810.PDF
  20. https://www.ee.torontomu.ca/~courses/ele818/VP.AppG.pdf
  21. https://people.eecs.berkeley.edu/~pattrsn/252S98/Lec07-vector.pdf
  22. https://gordonbell.azurewebsites.net/MSR-TR-2015-2_Supercomputers-The_Amazing_Race_Bell.pdf
  23. https://cvw.cac.cornell.edu/vector/intro/how-vector-works
  24. https://people.eecs.berkeley.edu/~pattrsn/252S98/Lec06-vector.pdf
  25. https://www.cs.umd.edu/~meesh/411/CA-online/chapter/exploiting-data-level-parallelism/index.html
  26. https://www.osti.gov/servlets/purl/7210319
  27. https://dl.acm.org/doi/10.1145/359327.359336
  28. https://www.ed-thelen.org/comp-hist/cray-res.html
  29. https://s3data.computerhistory.org/brochures/cray.cray1.1977.102638650.pdf
  30. https://american.cs.ucdavis.edu/academic/readings/papers/CRAY-technology.pdf
  31. http://s3data.computerhistory.org/brochures/cray.cray1s.1979.102646188.pdf
  32. https://study.com/academy/lesson/cray-1-supercomputer-history-facts-overview.html
  33. https://drhart.ucoz.com/index/cray_super_computer/0-116
  34. https://cray-history.net/2022/08/28/sonjas-story-about-cray-1-fabrication-and-assembly/
  35. https://www.thocp.callapple.org/hardware/cray_1.htm
  36. https://www.scorpion-engineering.co.uk/computing_history/cray-1s.html
  37. https://cray.modularcircuits.com/cray_docs/hw/CrayProdFam1989.pdf
  38. https://cray-history.net/cray-history-front/fom-home/
  39. http://bitsavers.informatik.uni-stuttgart.de/pdf/cray/CFT/2240207_Vectorization_and_Conversion_of_Fortran_Programs_for_the_CFT_Compiler.pdf
  40. https://cs.uwaterloo.ca/~mashti/cs850-f18/papers/cray1.pdf
  41. http://bitsavers.informatik.uni-stuttgart.de/pdf/cray/CAL/2240000B_Prelim_CAL_RefMan_Dec75.pdf
  42. http://pascal.hansotten.com/niklaus-wirth/recollections-about-the-development-of-pascal/
  43. https://archive.org/stream/bitsavers_crayCOSSM0criptionsInternalReferenceManual_27819770/SM-0045-I_Cray_COS_Table_Descriptions_Internal_Reference_Manual_djvu.txt
  44. https://dl.acm.org/doi/10.1145/29873.29875
  45. https://www.ebsco.com/research-starters/history/first-cray-1-supercomputer-shipped-los-alamos-national-laboratory
  46. https://cray-history.net/cray-history-front/cray-channels-notes/cray-channels-extract-customer-notes/
  47. https://cray-history.net/wp-content/uploads/2021/04/cc_v04_n1_OCRNew.pdf
  48. https://cray-history.net/wp-content/uploads/2021/08/CrayAircrafSimulation.pdf
  49. https://cray-history.net/wp-content/uploads/2021/04/cc_v05_n2_OCRNew.pdf
  50. https://cray-history.net/wp-content/uploads/2021/04/cc_v08_n1_OCRNew.pdf
  51. https://apps.dtic.mil/sti/tr/pdf/ADA276808.pdf
  52. https://cray-history.net/faq-1-cray-supercomputer-families/
  53. https://www.hpcwire.com/2016/09/26/vectors-old-became-new-supercomputing/
  54. https://ed-thelen.org/comp-hist/vs-cray-res.html
  55. https://www.researchgate.net/publication/223115918_Development_of_supercomputers_in_Japan_Hardware_and_software
  56. https://www.1000bit.it/ad/bro/cray/crayinterfacemagazine-mar1983.pdf
  57. https://www.sciencedirect.com/science/article/abs/pii/S0167819199000678
  58. https://mimmsmuseum.org/news/museum-rebrands/
  59. https://www.geekwire.com/2024/paul-allen-estate-sells-remaining-living-computers-artifacts-and-systems-to-museum-near-atlanta/
Add your contribution
Related Hubs
User Avatar
No comments yet.