Enter email address here to subscribe to B5500 blog posts...

Sunday, March 25, 2012

Starting the project

The Burroughs B5500 was an innovative computer system. Released first as the B5000 in 1962 and then slightly updated to the B5500 in 1964, its design was a radical departure from other commercial systems of the day. Many of the concepts that it embodied were being worked on and implemented by others around the same time, but I cannot think of another system that pulled so many concepts together and made them work in a commercially-successful product:
  • Multi-programming (multiple tasks sharing the same processor)
  • Multi-processing (multiple physical processors sharing common memory and I/O)
  • Automatic memory address relocation
  • Automatic memory segment overlay (what we now call virtual memory)
  • Variable-length memory segments
  • Hardware bounds checking
  • Unified integer/floating-point numeric format
  • Management by a sophisticated operating system, the Master Control Program, or MCP
  • Designed for and programmed exclusively in higher-level languages

That last bullet deserves special mention, because the B5500 was designed specifically to support Algol, new at the time, but now the patriarch of procedure-oriented languages, serving as the basis for, or at least heavily influencing, C, Pascal, and just about everything else since.

Alastair Mayer covered all of this in much more detail in his excellent 1982 article for the ACM SIGARCH Computer Architecture News (see http://dl.acm.org/citation.cfm?id=641543, with the text freely available at https://www.smecc.org/The%20Architecture%20%20of%20the%20Burroughs%20B-5000.htm [updated 2017-03-11]).

Nigel Williams and I, having taken leave of our senses, are embarking on a project to create an emulator for the B5500. Nigel is in Hobart, Tasmania (Australia) and I am in San Diego, California (USA). We share interests in the Burroughs architectures and in older computer systems in general. Nigel had experience with the B5500's successor, the B6700, while in university. I had some brief exposure to the B5500 at the end of my time in school, then went to work for Burroughs and have spent most of a career working with the B6700 and its follow-on systems, up to and including the Unisys ClearPath MCP systems still in production today. While we have a lot of related experience, neither of us could be considered a B5500 expert.

We have decided to skip over the original B5000 implementation and concentrate on the B5500, because (a) we have found very little technical documentation and absolutely no software for the B5000, and (b) as far as we are aware, all B5000s were converted to B5500s in the field. The B5500 implemented some tweaks to the processor, including a few new instructions, but architecturally was the same machine. The big advance with the B5500 was the availability of much higher-capacity rotating storage -- the Burroughs Head-per-Track disk. The B5000 supported only two 32K-word (256K 6-bit character) drums, while the B5500 could theoretically support up to almost 1G of 6-bit character storage.

The B5000 was not particularly successful, but the much larger HPT disk allowed the B5500 to reach its full potential and become both a technical and commercial success. It turns out that to support a sophisticated operating system, virtual memory, and the richer features of high-level languages, you needed lots of memory and disk. The B5500 remained in production until 1970, and some systems were still being used into the early 1980s. Experience with the B5500 allowed Burroughs to design the much more sophisticated B6500/6700, which as mentioned above, lives on as today's Unisys ClearPath MCP systems.

Emulating the B5500 is not going to be easy. The design is now 50 years old, and the machines went out of production more than 40 years ago. This was a complex machine, with a complex relationship between the hardware and the operating system and compilers. At present, we have no source or object code for it in machine-readable format. We understand that some 7-track tapes exist, and the Computer History Museum in Mountain View, California is apparently trying to reconstruct a 7-track transport to read them, but we can't be assured that they will be successful, or that those tapes are even readable.

There is, however, quite a bit of information available for the B5500 on bitsavers, including reference manuals, some hardware maintenance documents, and scans of listings of compilers and the operating system. We are basing our project largely on these.

Our overall approach is as follows:
  1. Design an emulator for the B5500 processor. Initially, we are going to try to support some basic I/O and operating system facilities from within the emulator, but it is not yet clear how well this might work.
  2. Recover the source for Extended Algol compiler and somehow get it to generate B5500 object code. The compiler is written in itself, so initially we are looking at porting it to the modern MCP, where it will serve as a cross-compiler for the B5500.
  3. Get the emulator to load and execute object code files. If possible, host the Algol compiler within the emulator environment.
  4. Eventually, produce a full emulation of the mainframe hardware, maintenance displays, operator's console, I/O units, and selected peripheral devices.
  5. Eventually, reconstruct the B5500 MCP operating system and ESPOL compiler from listings and get them to run within the emulator.
Work on items 1 and 2 above have begun. In later posts, Nigel and I will be discussing how we are approaching these and our progress to date.

We have established an open-source project on Google Code, http://code.google.com/p/retro-b5500/, to host the software and other artifacts for the project. We are in the process of establishing a wiki within that project for documentation and design notes.

We would welcome the participation of others in this project, especially if you have experience with the hardware or system software for the B5000 or B5500. If you have documentation or software -- in any form -- for these systems, we would love to hear from you, and we would encourage you to donate it to bitsavers so they can capture it and make it available to everyone. You can contact us through the project web site link above.


  1. Paul Kimpell and Nigel Williams have found an interesting and exciting project with the building of a B-5500 emulator. I am sure that many people learned about the power of recursion via Burroughs Algol, and like me wish every success for these two dedicated individuals. The initial posting makes interesting reading, and the energy required to re-type thousands of lines of code is impressive.

  2. A brief note adding to Paul's introduction. Paul and I have been discussing this project since 2010, and I am glad we've finally talked ourselves into starting this somewhat daunting project. With no B5500s still around (working or non-working) for comparison, limited detailed technical information and in my case no direct experience with the B5500, we remain cautiously wary of becoming the 'blind men and the elephant'.

    As we are still in the shadow of the 50th anniversary of the introduction of the B5000 family of machines (introduced 1961), it is certainly well overdue for resurrection as an emulator.

    We are seeking example software for these machines, particularly compiler listings which show the generated code. We have Tony Marsland's ALGOL chess program which competed in several early computer chess tournaments (http://webdocs.cs.ualberta.ca/~tony/Public/Awit-Wita-ComputerChess/). A bonus with Tony's chess program is that we have output listings from games won and lost so we can compare our results with the original and confirm we have correctly implemented the emulator.

    Thanks to Al Kossow of bitsavers.org for capturing and preserving so many B5000 series documents and program listings, this project would not have been possible without Al's exemplary efforts.