Jump to content

Atlas (computer)

From Wikipedia, the free encyclopedia
(Redirected from Atlas Computer (Manchester))
This article is about a British supercomputer. For the early American codebreaking computer also known as Atlas, see UNIVAC 1101.

Atlas
The University of Manchester Atlas in January 1963
Product familyManchester computers
Release date1962
Units sold3 (+ 3 Atlas 2)

The Atlas was one of the world's first supercomputers, in use from 1962 (when it was claimed to be the most powerful computer in the world) to 1972.[1] Atlas's capacity promoted the saying that when it went offline, half of the United Kingdom's computer capacity was lost.[2] It is notable for being the first machine with virtual memory (at that time referred to as "one-level store"[3]) using paging techniques; this approach quickly spread, and is now ubiquitous.

Atlas was a second-generation computer, using discrete germanium transistors. Atlas was created in a joint development effort among the University of Manchester, Ferranti and Plessey. Two other Atlas machines were built: one for BP and the University of London, and one for the Atlas Computer Laboratory at Chilton near Oxford.

A derivative system was built by Ferranti for the University of Cambridge. Called the Titan, or Atlas 2,[4] it had a different memory organisation and ran a time-sharing operating system developed by Cambridge University Computer Laboratory. Two further Atlas 2s were delivered: one to the CAD Centre in Cambridge (later called CADCentre, then AVEVA), and the other to the Atomic Weapons Research Establishment (AWRE), Aldermaston.

The University of Manchester's Atlas was decommissioned in 1971.[5] The final Atlas, the CADCentre machine, was switched off in late 1976.[6] Parts of the Chilton Atlas are preserved by National Museums Scotland in Edinburgh; the main console itself was rediscovered in July 2014 and is at Rutherford Appleton Laboratory in Chilton, near Oxford.

History

[edit]

Background

[edit]

Through 1956 there was a growing awareness that the UK was falling behind the US in computer development. In April, B.W. Pollard of Ferranti told a computer conference that "there is in this country a range of medium-speed computers, and the only two machines which are really fast are the Cambridge EDSAC 2 and the Manchester Mark 2, although both are still very slow compared with the fastest American machines."[7] This was followed by similar concerns expressed in May report to the Department of Scientific and Industrial Research Advisory Committee on High Speed Calculating Machines, better known as the Brunt Committee.[8]

Through this period, Tom Kilburn's team at the University of Manchester had been experimenting with transistor-based systems, building two small machines to test various techniques. This was clearly the way forward, and in the autumn of 1956, Kilburn began canvassing possible customers on what features they would want in a new transistor-based machine. Most commercial customers pointed out the need to support a wide variety of peripheral devices, while the Atomic Energy Authority suggested a machine able to perform an instruction every microsecond,[9] or as it would be known today, 1 MIPS of performance. This later request led to the name of the prospective design, MUSE, for microsecond engine.[10]

The need to support many peripherals and the need to run fast are naturally at odds. A program that processes data from a card reader, for instance, will spend the vast majority of its time waiting for the reader to send in the next bit of data. To support these devices while still making efficient use of the central processing unit (CPU), the new system would need to have additional memory to buffer data and have an operating system that could coordinate the flow of data around the system.[11]

Muse becomes Atlas

[edit]

When the Brunt Committee heard of new and much faster US designs, the Univac LARC and IBM STRETCH, they were able to gain the attention of the National Research Development Corporation (NRDC), responsible for moving technologies from war-era research groups into the market. Over the next eighteen months, they held numerous meetings with prospective customers, engineering teams at Ferranti and EMI, and design teams at Manchester and the Royal Radar Establishment.[11]

In spite of all this effort, by the summer of 1958, there was still no funding available from the NRDC. Kilburn decided to move things along by building a smaller Muse to experiment with various concepts. This was paid for using funding from the Mark 1 Computer Earnings Fund, which collected funds by renting out time on the University's Mark 1. Soon after the project started, in October 1958, Ferranti decided to become involved. In May 1959 they received a grant of £300,000 from the NRDC to build the system, which would be returned from the proceeds of sales. At some point during this process, the machine was renamed Atlas.[11]

The detailed design was completed by the end of 1959, and the construction of the compilers was proceeding. However, the Supervisor operating system was already well behind.[12] This led to David Howarth, newly hired at Ferranti, expanding the operating system team from two to six programmers. In what is described as a Herculean effort,[by whom?] led by the tireless and energetic Howarth (who completed his Ph.D. in physics at age 22), the team eventually delivered a Supervisor consisting of 35,000 lines of assembler language which had support for multiprogramming to solve the problem of peripheral handling.[13]

Installations

[edit]

The first Atlas was built up at the university throughout 1962. The schedule was further constrained by the planned shutdown of the Ferranti Mercury machine at the end of December. Atlas met this goal, and was officially commissioned on 7 December by John Cockcroft, director of the AEA.[13] This system had only an early version of Supervisor, and the only compiler was for Autocode. It was not until January 1964 that the final version of Supervisor was installed, along with compilers for ALGOL 60 and Fortran.[14]

By the mid-1960s the original machine was in continual use, based on a 20-hour-per-day schedule, during which time as many as 1,000 programs might be run. Time was split between the University and Ferranti, the latter of which charged £500 an hour to its customers. A portion of this was returned to the University Computer Earnings Fund.[14] In 1969, it was estimated that the computer time received by the University would cost £720,000 if it had been leased on the open market. The machine was shut down on 30 November 1971.[15]

Ferranti sold two other Atlas installations, one to a joint consortium of University of London and BP in 1963, and another to the Atomic Energy Research Establishment (Harwell) in December 1964. The AEA machine was later moved to the Atlas Computer Laboratory at Chilton, a few yards outside the boundary fence of Harwell, which placed it on civilian lands and thus made it much easier to access. This installation grew to be the largest Atlas, containing 48 kWords of 48-bit core memory and 32 tape drives. Time was made available to all UK universities. It was shut down in March 1974.[16]

Titan and Atlas 2

[edit]
Main article: Titan (1963 computer)

In February 1962, Ferranti gave some parts of an Atlas machine to University of Cambridge, and in return, the University would use these to develop a cheaper version of the system. The result was the Titan machine, which became operational in the summer of 1963. Ferranti sold two more of this design under the name Atlas 2, one to the Atomic Weapons Research Establishment (Aldermaston) in 1963, and another to the government-sponsored Computer Aided Design Center in 1966.[17]

Legacy

[edit]

Atlas had been designed as a response to the US LARC and STRETCH programs. Both ultimately beat Atlas into official use, LARC in 1961, and STRETCH a few months before Atlas. Atlas was much faster than LARC, about four times, and ran slightly slower than STRETCH - Atlas added two floating-point numbers in about 1.59 microseconds,[14] while STRETCH did the same in 1.38 to 1.5 microseconds. Nevertheless, the head of Ferranti's Software Division, Hugh Devonald, said in 1962: "Atlas is in fact claimed to be the world's most powerful computing system. By such a claim it is meant that, if Atlas and any of its rivals were presented simultaneously with similar large sets of representative computing jobs, Atlas should complete its set ahead of all other computers.".[18] No further sales of LARC were attempted,[17] and it is not clear how many STRETCH machines were ultimately produced.

It was not until 1964's arrival of the CDC 6600 that the Atlas was significantly bested. CDC later stated that it was a 1959 description of Muse that gave CDC ideas that significantly accelerated the development of the 6600 and allowed it to be delivered earlier than originally estimated.[17] This led to it winning a contract for the CSIRO in Australia, which had originally been in discussions to buy an Atlas.[17]

Ferranti was having serious financial difficulties in the early 1960s, and decided to sell the computer division to International Computers and Tabulators (ICT) in 1963. ICT decided to focus on the mid-range market with their ICT 1900 series,[19] a flexible range of machines based on the Canadian Ferranti-Packard 6000.

The Atlas was highly regarded by many in the computer industry. Among its admirers was C. Gordon Bell of Digital Equipment Corporation, who later praised it:

In architecture, the Manchester Atlas was exemplary, not because it was a large machine that we would build, but because it illustrated a number of good design principles. Atlas was multiprogrammed with a well defined interface between the user and operating system, had a very large address space, and introduced the notion of extra codes to extend the functionality of its instruction set.[20]

In June 2022 an IEEE Milestone was dedicated to the "Atlas Computer and the Invention of Virtual Memory 1957-1962".[21]

Design

[edit]

Hardware

[edit]
Atlas computer control console from the University of London, about 1964

The machine had many innovative features, but the key operating parameters were as follows (the store size relates to the Manchester installation; the others were larger):

  • 48-bit word size. A word could hold one floating-point number, one instruction, two 24-bit addresses or signed integers, or eight 6-bit characters.
  • A fast adder that used novel circuitry to minimise carry propagation time.
  • 24-bit (2 million words, 16 million characters) address space that embraced supervisor ('sacred') store, V-store, fixed store and the user store
  • 16K words of core store (equivalent to 96 KB), featuring interleaving of odd/even addresses
  • 8K words of read-only memory (referred to as the fixed store). This contained the supervisor and extracode routines.
  • 96K words of drum store (eqv. to 576 KB), split across four drums but integrated with the core store using virtual memory. The page size was 512 words,[22] i.e. 3072 bytes.[23][24]
  • 128 high-speed index registers (B-lines) that could be used for address modification in the mostly double-modified instructions. The register address space also included special registers such as the extracode operand address and the exponent of the floating-point accumulator. Three of the 128 registers were program counter registers: 125 was supervisor (interrupt) control, 126 was extracode control, and 127 was user control. Register 0 always held value 0.
  • Capability for the addition of (for the time) sophisticated new peripherals such as magnetic tape, including direct memory access (DMA) facilities
  • Peripheral control through V-store addresses (memory-mapped I/O), interrupts and extracode routines, by reading and writing special wired-in store addresses.
  • An associative memory (content-addressable memory) of page address registers to determine whether the desired virtual memory location was in core store
  • Instruction pipelining

Atlas did not use a synchronous clocking mechanism — it was an asynchronous processor — so performance measurements were not easy, but as an example:

  • Fixed-point register add – 1.59 microseconds
  • Floating-point add, no modification – 1.61 microseconds
  • Floating-point add, double modify – 2.61 microseconds
  • Floating-point multiply, double modify – 4.97 microseconds

Extracode

[edit]

One feature of the Atlas was "Extracode", a technique that allowed complex instructions to be implemented in software. Dedicated hardware expedited entry to and return from the extracode routine and operand access; also, the code of the extracode routines was stored in ROM, which could be accessed faster than the core store.

The uppermost ten bits of a 48-bit Atlas machine instruction were the operation code. If the most significant bit was set to zero, this was an ordinary machine instruction executed directly by the hardware. If the uppermost bit was set to one, this was an Extracode and was implemented as a special kind of subroutine jump to a location in the fixed store (ROM), its address being determined by the other nine bits. About 250 extracodes were implemented, of the 512 possible.

Extracodes were what would be called software interrupts or traps today. They were used to call mathematical procedures which would have been too inefficient to implement in hardware, for example sine, logarithm, and square root. But about half of the codes were designated as Supervisor functions, which invoked operating system procedures. Typical examples would be "Print the specified character on the specified stream" or "Read a block of 512 words from logical tape N". Extracodes were the only means by which a program could communicate with the Supervisor. Other UK machines of the era, such as the Ferranti Orion, had similar mechanisms for calling on the services of their operating systems.

Software

[edit]

Atlas pioneered many software concepts still in common use today, including the Atlas Supervisor, "considered by many to be the first recognisable modern operating system".[25]

One of the first high-level languages available on Atlas was named Atlas Autocode, which was contemporary to Algol 60 and created specifically to address what Tony Brooker perceived to be some defects in Algol 60. The Atlas did however support Algol 60, as well as Fortran and COBOL, and ABL (Atlas Basic Language, a symbolic input language close to machine language). Being a university computer it was patronised by a large number of the student population, who had access to a protected machine code development environment.

Several of the compilers were written using the Brooker Morris Compiler Compiler (BMCC), considered to be the first of its type.

It also had a programming language called SPG (System Program Generator). At run time an SPG program could compile more program for itself. It could define and use macros. Its variables were in <angle brackets> and it had a text parser, giving SPG program text a resemblance to Backus–Naur form.

From the outset, Atlas was conceived as a supercomputer that would include a comprehensive operating system. The hardware included specific features that facilitated the work of the operating system. For example, the extracode routines and the interrupt routines each had dedicated storage, registers and program counters; a context switch from user mode to extracode mode or executive mode, or from extracode mode to executive mode, was therefore very fast.

See also

[edit]

References

[edit]
  1. ^ Lavington 1975, p. 34
  2. ^ Lavington 1998, pp. 44–45
  3. ^ Hayes, John.P (1978), Computer Architecture and Organization, p. 21, ISBN 0-07-027363-4
  4. ^ "COMPUTERS AND CENTERS, OVERSEAS: 2. Ferranti Ltd., Atlas 2 Computer, London Wl, England". Digital Computer Newsletter. 16 (1): 13–15. 1964. Archived from the original on 3 June 2018.
  5. ^ Lavington 1998, p. 43
  6. ^ Lavington 1998, p. 44
  7. ^ Lavington 1975, pp. 30–31.
  8. ^ Lavington 1975, p. 30.
  9. ^ Lavington 1975, p. 31.
  10. ^ The Atlas, University of Manchester, archived from the original on 28 July 2012, retrieved 21 September 2010
  11. ^ a b c Lavington 1975, p. 32.
  12. ^ Lavington 1975, p. 33.
  13. ^ a b Lavington 1975, p. 34.
  14. ^ a b c Lavington 1975, p. 35.
  15. ^ Lavington 1975, p. 36.
  16. ^ Lavington 1975, p. 37.
  17. ^ a b c d Lavington 1975, p. 38.
  18. ^ Lavington, Simon (2012), The Atlas Story (PDF), p. 7
  19. ^ Lavington 1975, p. 39.
  20. ^ Bell et al. 1978, pp. 491.
  21. ^ "Milestones:Atlas Computer and the Invention of Virtual Memory, 1957-1962". 19 December 2022.
  22. ^ Hayes, John.P (1978), Computer Architecture and Organization, p. 375, ISBN 0-07-027363-4
  23. ^ Cronin, D.E. (31 January 1965). I.C.T. Atlas 1 Computer Programming Manual for Atlas Basic Language (ABL) (PDF). London: International Computers and Tabulators Limited. p. 12.1/1.
  24. ^ "12. Further Facilities and Techniques". The I.C.T. Atlas I Computer Programming Manual. January 1965.
  25. ^ Lavington 1980, pp. 50–52

Bibliography

[edit]

Further reading

[edit]
[edit]
Retrieved from "https://en.wikipedia.org/w/index.php?title=Atlas_(computer)&oldid=1247501880"