Майнфреймы Burroughs B2500–B4900: Архитектура, ориентированная на COBOL

The Burroughs B2500 through Burroughs B4900 was a series of mainframe computers developed and manufactured by Burroughs Corporation in Pasadena, California, United States, from 1966 to 1991. They were aimed at the business world with an instruction set optimized for the COBOL programming language. They were also known as Burroughs Medium Systems, by contrast with the Burroughs Large Systems and Burroughs Small Systems.

The B2500 and B3500 computers were announced in 1966. They operated directly on COBOL 68's primary decimal data types: strings of up to 100 digits, with one EBCDIC or ASCII digit character or two 4 bit binary coded decimal BCD digits per byte. Portable COBOL programs did not use binary integers at all, so the B2500 did not either, not even for memory addresses. Memory was addressed down to the 4 bit digit in big endian style, using 5 digit decimal addresses. Floating point numbers also used base 10 rather than some binary base, and had up to 100 mantissa digits. A typical COBOL statement 'ADD A, B GIVING C' may use operands of different lengths, different digit representations, and different sign representations. This statement compiled into a single 12 byte instruction with 3 memory operands. Complex formatting for printing was accomplished by executing a single EDIT instruction with detailed format descriptors. Other high level instructions implemented "translate this buffer through this (e. g. EBCDIC to ASCII) conversion table into that buffer" and "sort this table using these sort requirements into that table". In extreme cases, single instructions could run for several hundredths of a second. MCP could terminate over long instructions but could not interrupt and resume partially completed instructions. (Resumption is a prerequisite for doing page style virtual memory when operands cross page boundaries.) The machine matched COBOL so closely that the COBOL compiler was simple and fast, and COBOL programmers found it easy to do assembly programming as well. In the original instruction set, all operations were memory to memory only, with no visible data registers. Arithmetic was done serially, one digit at a time, beginning with most significant digits then working rightwards to least significant digits. This is backwards from manual right to left methods and more complicated, but it allowed all result writing to be suppressed in overflow cases. Serial arithmetic worked very well for COBOL. But for languages like FORTRAN or BPL, it was much less efficient than standard word oriented computers. Three reserved memory locations were used as address indexing 'registers'. The third index register was dedicated to pointing at the current procedure's stack frame on the call/return stack. Other reserved memory locations controlled operand sizes when that size was not constant. The B3500 was similar to the B2500 but with a faster cycle time and more expansion choices. The B2500 had a maximum of 60 K bytes of core memory and a 2 microsecond cycle time. The B3500 had a maximum of 500 K bytes and a 1 microsecond cycle time. B2500/3500 weighed about .

The B2500/B3500 machines were followed by B2700/B3700/B4700 in 1972; The B2800/B3800/B4800 in 1976, The B2900/B3900/B4900 in 1980 (which was the first of the range to load its microcode from floppy disk, rather than implementing it as hardware read only memory) and finally the Unisys V Series machines V340 V560 in 1985 90. Machines prior to the B4800 had no cache memory. Every operand byte or result byte required its own separate main memory cycle, which limited program performance. To compensate for this, the B3700/B4700 generation used semiconductor main memory that was faster but more expensive and power hungry than the DRAM used in competing machines. The unusual use of decimal numbers as memory addresses was initially no problem; it merely involved using 1 in 5 rather than 1 in 8 decoder logic in the core memory's row selects and bank selects. But later machines used standard memory chips that expected binary addresses. Each 1000 byte block of logical memory could be trivially mapped onto a subset of 1024 bytes in a chip with only 2.3% waste. But for denser chips and larger total memories, the entire decimal address had to be crunched into a shorter quasi binary form before sending the address to the chips, and done again for each cache or memory cycle. This conversion logic slowed the machine cycle somewhat. An attempted redesign in 1975 of the address space was called MS 3 for "Medium Systems 3rd Generation", but that project was cancelled. Machines before the B2900 allowed input numbers with 'undigit' values above 9, but arithmetic on this gave unspecified results. This was used as a form of hexadecimal arithmetic within the MCP and also by some application programmers. Later versions discontinued this and instead supported two new opcodes (binary to decimal and decimal to binary) to support addressing the hard drives available after Burroughs's acquisition of Memorex.

Unisys cancelled further V series hardware development in 1991, and support ended in 2004. In the B4900 and later machines, integer operations of 10 digits or less were now handled in parallel; only longer operands continued to use the serial method. And all floating point operations were limited to 17 digits of precision. Later Medium Systems machines added an accumulator register and accumulator/memory instructions using 32 bit, 7 digit integers and 48 bit or 80 bit floating point values, all aligned on 16 bit word boundaries.

The operating system was called MCP, for Master Control Program. It shared many architectural features with the MCP of Burroughs' Large Systems stack machines, but was entirely different internally, and was coded in assembly language, not an ALGOL derivative. Programs had separate address spaces dynamically relocated by a base register, but otherwise there was no virtual memory; no paging and no segmentation. Larger programs were squeezed into the limited code address space by explicit overlays. The nonresident parts of MCP were also heavily overlaid. Initially, code and data shared a single 300,000 digit address space. Later machines had separate million digit spaces for program code and process data. Instructions' address fields were extended from five digits to six digits, and four more real index registers were added. Early machines used Burroughs's head per track disk systems rather than the now standard movable head platter disks. In one attempt to speed up MCP, its overlays were carefully laid out so that the likely next overlays would soon arrive at their read head just after the current overlay completed. This was similar to time dependent layout optimizations on early delay line and drum computers. But this turned out to be impractical to maintain after software changes, and better results were consistently achieved with a totally randomized layout of all MCP overlays. Other than the operating system itself, all system software was coded in BPL (Burroughs Programming Language), a systems programming language derived from ALGOL and Large System's ESPOL systems language. The initial COBOL compiler supported the ANSI 68 specification and supported the ENTER SYMBOLIC syntax to allow inline assembly language coding, but lacked support for RELATIVE and INDEXED file support; these were later added into the ANSI 74 version of the compiler, which was released in 1982. MCP allowed programs to communicate with each other via core to core transmissions (CRCR) or by using storage queues (STOQ), implemented as system calls using the BCT instruction and exposed to the languages (COBOL FILL FROM/INTO). This was unheard of except on the very largest IBM System/360 systems of the time, and even then it was a major operational headache to manage the interactions of the multiple program streams.