Burroughs Large Systems

The Burroughs line of computers, first introduced in 1961 and is considered the first of the “3rd generation” systems [1].  This generation of systems is hallmarked by the use of integrated circuits, peripheral interfaces (keyboards, monitors), and their support for time sharing operating systems.  Many of the features introduced in this line of computers,initially criticized as being overly complex, are still considered new and innovative.

The B5000 was designed with high level language support in mind, especially for “block structured” languages such as ALGOL and COBOL [1].  Support for FORTRAN and APL, which required support for repetitive arithmetic operations on arrays and vectors, was added in the B6700/B7700 line.

Notable features introduced in the original line include a hardware managed stack and the use of descriptors for data access.  This allowed for the introduction of virtual memory as well as support for multiprogramming and multiprocessing [1].  For data security, code and data were distinguished using a flag bit – the hardware would not execute data or alter code without first having this bit set properly – this made self modifying code impossible [1].  The following is a summary of the supported features and implementation details.

High level language support, as mentioned earlier was a driving design goal.  To facilitate this, the machine offered a hardware managed stack, which made compile writing easier.  It also supported the data descriptors.  Later incarnations of this line moved the descriptor bits outside of the 48 bit word [1].

As was the IBM/360, the hardware and the operating systems were designed with respect to one another.  The core of the OS was something called the Master Control Program [1].  It included special instructions that assisted memory management and processor control operations that facilitated multi-processor environments.  The one specified in [1], and one which I find particularly interesting, is the HEYU instruction.  More on this later.

The use of descriptor bits also helped easily implement virtual memory since it (eventually changed from 1 bit to 3) could be used to denote if a block of memory was an array or some other segment [1].

The instruction set was refined as time went on, but not very much.  By all accounts, it was a simple instruction set, and one that facilitated the taking of full advantage of the hardware.  The ability to tag data also reduced the number of instructions needed since the opt-code could distinguish between the likes of single and double precision.  For example, the B5000 had 2 ADD instructions (for single and double precision), but crafty use of the data tagging field allowed the B6000 to reduce this instruction to a single ADD.

Probably the single most “modern” features offered by this line is its support for multitasking and symmetric multi-processing (SMP).  In fact, it even supported concurrent programming in ALGOL and COBOL [1] – something that I think is still outside the realm of most programmers.  Some features supporting multitasking included: the read-lock instruction, which can be used for task synchronization, and the HEYU command which allows the interruption of all concurrent processes.

The IBM System/360 was innovative in its own right.  A show case for Brooks‘ management skills and of Amdahl‘s technical prowess and forward thinking, this system became a huge success because of the thoughtful analysis of customer needs – both on a practical and technological scale.  The system was designed from the ground up to be configurable in the small to large machine spectrum.  It was designed as a general purpose computer to meet the computing needs of nearly all applications – including scientific computing. Their analysis of what made a practical and productive computing system was extremely “Brooks-like”, particular with their focus of “answers-per-month” versus bits-per-microsecond.

Advanced concepts discussed in [2], include the following.

The development of computers as “families” of backward and forward compatible systems.  This appealed to the business decisions of their customers as well as the technical ability to add to an existing infrastructure to meet increasing and changing needs.

A general I/O systems was required – this was similar to the use of the desire for devices such as monitors and keyboards on the Burroughs line.  The observation was made that most of the cycles take up by the CPU had to do with system level demands – compiling, I/O, traversing data structures, etc [2].  These functions had to be made efficient.

Perhaps one of great concepts was that of the system supervising itself.  While the Burroughs line was able to create a reliable and self monitoring system, the 360 took this to a new level by stepping aside the need for manual interactions.  It was my impression that the 360 implemented this in a much more robust way that the Burroughs line.  It is also an area of research still pursued by IBM.  This also affected the need for redundant systems – disks, cpu’s, etc.

The system required a storage capacity greater than the 32,000 words.  It also recognized the need of applications that required floating point sizes of greater than 36 bits.

The paper went into some pretty fine detail about the implementation of the data types, character set used, and how the sub systems were coordinated to provide an efficient, general purpose machine.  With out a doubt the 360 was a technical success that served IBM’s customers very well.


Some key differences between the IBM 360 and the Burroughs line included:

1. Use of stack (Burroughs) versus named registers (360)
2. Support for high level languages versus general purpose applications
3. Differences on data and memory management
4. Differences in approaches regarding system reliability


Both systems are milestones in the development of useful, large scale computing systems.  The Burroughs like introduced features that are still considered new today.  In this day and age of general purpose hardware for general purpose operating systems, it is refreshing to read about a day and age when the hardware *and* the operating systems were developed with respect to one another.  It seems as if the days of getting the most out of your hardware by using smart design choices on the software and hardware level are currently gone.


[1] The Architecture of the Burroughs B5000 – 20 Years Later and Still Ahead of the Times?; Alastair J.W. Mayer
[2] The Architecture of the IBM System/360; G.M. Amdahl, G.A. Blaauw, F.P. Brooks, Jr.

This entry was posted in History of Computing Machinery and tagged , , , , . Bookmark the permalink.

Leave a Reply