Burroughs B5000 – the first computer with stack architecture

The beginning of the sixties is the era of mainframes, a time when computing machines stepped beyond military laboratories, becoming the working tool of scientists and engineers. In 1961, Burroughs introduced one of the most innovative computers of its time, the Burroughs B5000. This machine was radically different from other mainframes due to the unusual approach taken by the developers to design and software, and became the first computer in history to implement a stack architecture.

Birth of the B5000

Like many other companies that entered the computing market at the turn of the 50s and 60s, the Burroughs Large Systems group of companies debuted back in the 1880s with mechanical adding machines. However, by 1960, electronic computers were no longer considered a curiosity; many of them had the status of commercial products. That is, there was no talk of mass serial production yet, but the construction of mainframes to order was quite commonplace. In order to somehow compete in this growing market, Burroughs decided to design the mainframe using the most advanced and modern technologies of its time, and most importantly, with an eye to the use of high-level languages. This would significantly expand the pool of specialists capable of working with such a computer, and at the same time would make the human-computer interface more convenient and understandable for an operator with an average level of training.

The first characteristic feature of the B5000 was that the developers completely ignored FORTRAN, which had appeared back in 1957, and relied on the less common languages ​​ALGOL and COBOL. The computer was created by the team of Robert Barton, a former IBM employee, an outstanding engineer, cybernetics specialist and professor at the University of Utah.

The approach to designing the B5000 itself was considered quite innovative for its time: usually engineers first developed the hardware architecture of the computer, and then provided the appropriate documentation to software developers so that they could write software for this architecture. Burroughs did exactly the opposite: first they prepared the requirements for software and programming languages, and only then began to create hardware for them.

B5000 architecture

The architecture of this computer was based on the use of a hardware-controlled stack for calculations and the widespread use of descriptors for accessing data. Additionally, the Burroughs B5000 was one of the first commercial computers to use virtual memory. For added security, code and data were separated in memory by a special “flag bit”, and the hardware could not process the data or change the code without first explicitly changing this flag. The B5000 is considered one of the first machines to feature multitasking and memory protection at the hardware level. This was implemented using a system of stacked data structures that allowed the execution of multiple tasks to be managed securely. Each task had its own stack, and the processor could switch between them, providing a high degree of parallelism.

Actually, the stack architecture became the main “highlight” of the B5000, which distinguished this computer from other computers of that time. Data operations in the B5000 processor were organized according to the LIFO (Last In, First Out) principle, that is, the last entered element is retrieved first. Stack architecture makes it easier to manage calculations and use variables by allowing the processor to automatically save and restore data. Stack machines operate without the use of general-purpose registers (as in traditional processors), relying on the stack for everything from arithmetic to subroutine calls.

Unlike most other systems, in which the stack was implemented in software or indirectly through other resources (for example, through registers), in the B5000 the stack was built into the hardware configuration of the machine, which ensured high speed of operations. This eliminated the need to manually manage registers for each variable.

The B5000 stack machine organized its work in such a way that each operation involved the use of data already on the stack. For example, if two numbers needed to be added, both values ​​were first pushed onto the stack, after which the addition operation was performed and the result was stored on the top of the stack. One of the main advantages of the stack architecture was how easily it supported calling subroutines. Each time a program called a subroutine, the machine pushed the program's current state—the return address, variable values, and other data—on the stack and transferred control to the subroutine. After the subroutine completed, the stack was cleared and the program continued execution from where it left off.

In other words, this computer implemented several advanced concepts for 1961 that many competitors could not boast of, for example, the computer supported the concept of time sharing, which allowed several users to work simultaneously with one machine.

Software

ALGOL-60 was chosen as the main programming language used to work with the Burroughs B5000, or rather, its Elliott ALGOL dialect, first developed and implemented by the English scientist Charles Anthony Richard Hoare on Elliott 503. It is noteworthy that in the process of developing software for the B5000 The well-known Donald Knuth, who already had experience working with ALGOL-58 on one of the early computers of this company, acted as a consultant to the company. At the same time, the Assembly language was not available to the B5000 user.

Most computers in 1961 were not very fast, and high-level language compilers worked extremely slowly on them, which is why many programmers preferred Assembly. The main reason was that early computers did not have enough RAM to store the entire amount of source code for a program, so they (and even Assembly compilers) typically had to read the source code in several iterations, compile the program in blocks, and then put it together. The ALGOL compiler for the B5000, on the contrary, was single-pass, due to which it worked very quickly, so much so that this speed surprised experts. This was also facilitated by the special “Algol” syntax for this computer: unlike the “official” version of the language, the ALGOL dialect for the B5000 required that all variables be declared before use, thanks to which the compiler was able to read all the data in one pass. It is believed that it was largely due to this feature that Burroughs received the first orders for its computer from the University of Eindhoven in the Netherlands.

The B5000's COBOL compiler was also single-pass and very fast: a COBOL program that took 4,000 punch cards compiled at the same speed that other computers of the time were capable of just reading the code of such a program.

Further evolution

The Burroughs B5000 turned out to be such a successful computer that Burroughs Large Systems began producing improved versions of this computer in subsequent years. The B5500 appeared in 1964, the B6500 in 1966, then the B5700 and B6700. The use of descriptors was expanded, the flag went from being one-bit to three-bit and external to the 48-bit data word, and the instruction set was modified to take advantage of these changes. Descriptors were a memory segmentation tool and were used to address those segments. They were originally invented as a mechanism for accessing arrays: descriptors allowed bounds checking and simplified dynamic array allocation (this is also important for ALGOL programs). With their help, the compiler could distinguish between arrays of words and strings of characters, and received the size of such strings in bits. It was with the help of descriptors that virtual memory was implemented in the B5000 and computers of subsequent generations.

The hardware differences between the above models were in the number and arrangement of processors: for example, the B6700 could have up to three central processing units and up to three I/O processors, and the later B7700 could have up to eight such processors in various combinations. At some point, vector mode hardware was added to the Burroughs computer architecture, making the use of the APL language possible and enhancing the processor's ability to quickly perform repetitive arithmetic operations.

In the 1970s, Burroughs Corporation was divided into three divisions, producing computers in different product lines: high-end, mid-range and entry-level. Burroughs then acquired Sperry Corporation and changed its name to Unisys, after which it continued to develop new machines based on CMOS ASICs.

One of the main merits of the B5000 is the contribution of this computer to the development of high-level languages. As the first system designed specifically to run ALGOL programs, the B5000 proved that high-level languages ​​can be not only programmer friendly, but also hardware efficient. This became the starting point for the creation of languages ​​such as Pascal, C and other modern programming languages. The stack architecture implemented in the B5000 was later used in microprocessors and modern computers. She demonstrated how using a stack at the hardware level can simplify software development and speed up operations. This was an important step in the evolution of architectures focused on working with high-level programming languages ​​and solving problems that are now considered the standard in the computer industry. The idea of ​​hardware stack support was used in later Burroughs machines such as the B5500 and B6700, as well as in a number of other computing systems.

The article is supported by the team Serverspace.

Serverspace – a cloud service provider that provides rental virtual servers with Linux and Windows OS in 8 data centers: Russia, Belarus, Kazakhstan, the Netherlands, Turkey, USA, Canada and Brazil. To build an IT infrastructure, the provider also offers: creation of networks, gateways, backups, CDN, DNS services, S3 object storage.

IT infrastructure | Double the first payment by code HABR