- 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:
- 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.
- 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.
- Get the emulator to load and execute object code files. If possible, host the Algol compiler within the emulator environment.
- Eventually, produce a full emulation of the mainframe hardware, maintenance displays, operator's console, I/O units, and selected peripheral devices.
- Eventually, reconstruct the B5500 MCP operating system and ESPOL compiler from listings and get them to run within the emulator.
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.