In 1961 Burroughs introduced the B5000. Many new hardware/software computing ideas were implemented in this system. One of B5000 selling points was that it offered "higher level" programming languages (ALGOL and COBOL) as the human interface to the system. At the time, this was seen as a novelty, since very few higher level languages had been implemented. Burroughs, ignored FORTRAN (which was steadily gaining market share), and decided to go with what they thought was the "better" language--ALGOL. The B5000 hardware concerns were designed with ALGOL in mind, and this led the designers to create a machine where compilers worked fast, and execution of the object code took advantage of the structure of the object code. Thus, the B5000, with its stack based processing, took advantage of a machine object code formulated in Polish notation. [3, 5]
ALGOL 60 and COBOL 61 were two high level languages provided by the B5000 system. ALGOL 60 was a high level "computational language," while COBOL 61 was a high level "data processing" language developed expressly for the purpose of handling business data. [1, p. 2-1] These languages were abstract enough, so that according to Burroughs:
The programmer works in the language of his problem, either algebraic notation or English narrative statements. The B 5000 has compiler-oriented machine language and logic which accept the common languages of ALGOL and COBOL. Because the machine language of the B 5000 is similar to these problem languages, compilation time is reduced and object-program redundancies eliminated.[1, p. 1-1]According to Burroughs:
A traditional compiler does three basic things.Burroughs decided to combine the last two steps into one step. Thus, the B5000 "translators" translated ALGOL and COBOL into a "machine" language, that was formulated in Polish notation, in just "one step." Thus, the B5000 compiled the ALGOL and COBOL languages into what the B5000 understood as "native" machine code written in Polish notation. In this way, Burroughs was able to considerably decrease the compilation time. [1, p. 2-3, 2-4]
- Examine the programmer's language.
- Create an intermediate language.
- Produce machine language. [1, p. 2-3]
An interesting consequence of requiring the programmer to work in a high level language is that the machine code is never exposed. This made it possible to run the same program, unmodified, on later Burroughs systems regardless of how the internal architecture had changed. Burroughs is freed from having to maintain backwards compatibility when upgrading the architecture, thus avoiding being stuck with a language for years as Intel is with x86.
Today the B5000 sytems architecture is referred to as a "descriptor architecture." The B5000 implemented many new hardware techniques, but:
Most important was the use of segmentation for structuring memory and the use of descriptors for addressing segments. Also, the B5000 was geared to execute high-level language programs, particularly ALGOL and COBOL. In fact, assembly language was not available to the user. The system was designed to compile and execute high-level languages efficiently, and relied on a stack-orientated instruction set to aid in expressing evaluation and procedure activation. The B5000 supported multiprocessing as well as multiprogramming by allowing connection of two processing units. [4, p. 22, 23]
A computer word was 48 bits, and could be one of three things: a descriptor, an operand, or a program word. [1, p. 3-2, 3-3] A program word is divided into syllables that are defined to be 1/4 of a word (12 bits in the B5000). A syllable is the "basic unit of B5000 program strings," much like today's byte--but not quite.[1, p. C-5]
Burroughs defined a descriptor as a "computer word used specifically to define characteristics of a program element."[1, p. C-1] A descriptor could be used for the identification of such things as "describing a data record, a segment of a program, or an input-output operation."[1, p. C-1]
The formats for these 3 descriptors are illustrated in the following tables. [4, p. 24]
| Tag | P | Drum # | Segment size | Drum address | Memory address |
|---|
| Tag | P | Unit # | Operation size | Operation type | Format control | Memory adddress |
|---|
Programs were broken up into segments in the so-called Program Reference Table, or PRT.
The Program Reference Table, up to 1024 48-bit words in length, contains descriptors that locate the user's code and data segments in memory, and values of scalar elements [...]. A tag field in each word in the table indicates whether the entry is a descriptor or a scalar data element. All memory references, including procedure calls, are made through Program Reference Table descriptors; thus, the Program Reference Table completely defines the domain of execution for each user program. When a program is running, a hardware register holds the address of its Program Reference Table. [4, p. 23]
Core memory contains several memory stacks for multiprocessing, as well as the the PRT. The Stack utilizes the "last in, first out" principle, and the Stack values are accessible only through two arithmetic registers named A and B. "The[se] registers form the first and second locations of the Stack, and information transferred to or from the Stack passes through them." [1, p. 3-3] Additionally, there is register S, which stores a pointer to the current top of the Stack. The result of an operation on registers A and B is stored in register B. And then the pointer to the new top of the stack is stored in register S. For example:
[...] assume that a series of operations uses the information stored in the A and B registers and in Stack locations 1002 and 1001 [...]. The result of the operations is held in the B register, and the S register is set to location 1000. [...] (Note that the A register is empty, and therefore the B register has become the top of the Stack; if both registers were empty, location 1000 would be the top of the Stack.) [1, p. 3-3]Because all operations occur on the top of the stack and data is tagged with a descriptor describing its type, the B5000 could have used the same instruction internally for every variation of an operator. For example, the operator for adding 2 single precision numbers could be the same as the one used for adding double precision numbers as well as combinations of the two. The processor would be able to decide at runtime how to handle each statement. It would know to operate on the two values on the top of the stack, and it would know their types from their descriptors.
We really can't do better than Burroughs did in summerizing their hardware, as they did in their B5000 Information Brochure. Thus, the following are quotations taken from this brochure.
One or two parallel, independent, solid state processors may be installed. Each has a 1 megacycle clock rate with average add execution time of 3 microseconds. Processors operate on 49-bit words (48 bits plus parity bit) which may be interpreted in binary or alphanumeric form with common fixed-point and floating-point number representation. Instruction format: 12-bit operators or addresses, packed 4 to a word, executed sequentially with unlimited indexing ability. Internal operation is word and/or character oriented. [2]
One to eight high speed, coincident-current, magnetic core modules may be installed with read access time of 3 microseconds and 6 microsecond memory cycle. There are 4096 49-bit words per module. Each memory module has its own access address register, permitting simultaneous access by processors or input/output control channels.[2]
One to 4 independent input/output control channels may be used. Any of these channels may interconnect any memory module and any input/output device. With 4 channels in use, 4 input/output operations may be performed simultaneously with computation.[2]
One or two magnetic drums provide fast random access bulk storage. One drum (capacity 32,768 49-bit words) is standard with one processor. A second independent drum may be added to a system. Read-write rate: 8.1 microseconds per character. [2]