Burroughs Large Systems - Knowledge (XXG)

2159:

instruction (value call) that loaded an operand onto the stack. This op-code was two bits long and the rest of the byte's bits were concatenated with the following byte to give a fourteen-bit addressing field. The code being executed would be at some lexical level, say six: this meant that only lexical levels zero to six were valid, and so just three bits were needed to specify the lexical level desired. The address part of the VALC operation thus reserved just three bits for that purpose, with the remainder being available for referring to entities at that and lower levels. A deeply nested procedure (thus at a high lexical level) would have fewer bits available to identify entities: for level sixteen upwards five bits would be needed to specify the choice of levels 0–31 thus leaving nine bits to identify no more than the first 512 entities of any lexical level. This is much more compact than addressing entities by their literal memory address in a 32-bit addressing space. Further, only the VALC opcode loaded data: opcodes for ADD, MULT and so forth did no addressing, working entirely on the top elements of the stack.

1606:

Edit) which was developed as the online program development environment. The University of Otago in New Zealand developed a skinny program development environment equivalent to CANDE which they called SCREAM/6700 in the same time that IBM was offering a remote time-sharing/program development service known as CALL/360 which ran on IBM 360 series systems. Another MCS named COMS was introduced around 1984 and developed as a high performance transaction processing control system. There were predecessor transaction processing environments which included GEMCOS (GEneralized Message COntrol System), and an Australian Burroughs subsidiary developed MCS called TPMCS (Transaction Processing MCS). The transaction processing MCS's supported the delivery of application data to online production environments and the return of responses to remote users/devices/systems.

2172:

and use it as the offset into the array's address space, with bound checking provided by the hardware. By default, should an array's length exceed 1,024 words, the array would be segmented, and the index be converted into a segment index and an offset into the indexed segment. There was, however, the option to prevent segmentation by specifying the array as LONG in the declaration. In ALGOL's case, a multidimensional array would employ multiple levels of such addressing. For a reference to A, the first index would be into an array of descriptors, one descriptor for each of the rows of A, which row would then be indexed with j as for a single-dimensional array, and so on for higher dimensions. Hardware checking against the known bounds of all the array's indices would prevent erroneous indexing.

1951:

access to the enclosing environment and this is a very efficient IPC (Inter Process Communication) mechanism. Since two or more tasks now have access to common variables, the tasks must be synchronized to prevent race conditions, which is handled by the EVENT data type, where processes can WAIT on one, or more, events until it is caused by another cooperating process. EVENTs also allow for mutual exclusion synchronization through the PROCURE and LIBERATE functions. If for any reason the child task dies, the calling task can continue – however, if the parent process dies, then all child processes are automatically terminated. On a machine with more than one processor, the processes may run simultaneously. This EVENT mechanism is a basic enabler for multiprocessing in addition to multitasking.

1378:, handled the larger B7x00 line. All machines from both lines were fully object-compatible, meaning a program compiled on one could be executed on another. Newer and larger models had instructions which were not supported on older and slower models, but the hardware, when encountering an unrecognized instruction, invoked an operating system function which interpreted it. Other differences include how process switching and I/O were handled, and maintenance and cold-starting functionality. Larger systems included hardware process scheduling and more capable input/output modules, and more highly functional maintenance processors. When the Bxx00 models were replaced by the A Series models, the differences were retained but no longer readily identifiable by model number. 1589:(Network Definition Language) compiler generated the DCP code and NDF (network definition file). Ultimately, a further update resulted in the development of the NDLII language and compiler which were used in conjunction with the model 4 and 5 DCPs. There was one ALGOL function for each kind of DCP instruction, and if you called that function, then the corresponding DCP instruction bits would be emitted to the output. A DCP program was an ALGOL program comprising nothing but a long list of calls on these functions, one for each assembly language statement. Essentially ALGOL acted like the macro pass of a macro assembler. The first pass was the ALGOL compiler; the second pass was running the resulting program (on the B6500) which would then emit the binary for the DCP. 2163:

Offsets from a specified D-register would be checked by the hardware against the stack frame bound: rogue values would be trapped. Similarly, within a task, an array descriptor contained information on the array's bounds, and so any indexing operation was checked by the hardware: put another way, each array formed its own address space. In any case, the tagging of all memory words provided a second level of protection: a misdirected assignment of a value could only go to a data-holding location, not to one holding a pointer or an array descriptor, etc. and certainly not to a location holding machine code.

2142:

program could call another program's code, creating a D stack frame pointing to another process' D environment on top of its own process stack. At an instant the whole address space from the code's execution environment changes, making the D environment on the own process stack not directly addressable and instead make the D environment in another process stack directly addressable. This is how library calls are implemented. At such a cross-stack call, the calling code and called code could even originate from programs written in different source languages and be compiled by different compilers.

2554:, four to a word. The architecture has two modes, Word Mode and Character Mode, and each has a separate repertoire of syllables. A processor may be either Control State or Normal State, and certain syllables are only permissible in Control State. The architecture does not provide for addressing registers or storage directly; all references are through the 1024 word Program Reference Table, current code segment, marked locations within the stack or to the A and B registers holding the top two locations on the stack. Burroughs numbers bits in a syllable from 0 (high bit) to 11 (low bit) 1568:." Another story is that circa 1976, John McClintock of Burroughs (the software engineer developing NEWP) named the language "NEWP" after being asked, yet again, "does it have a name yet": answering "nyoooop", he adopted that as a name. NEWP, too, was a subset ALGOL extension, but it was more secure than ESPOL, and dropped some little-used complexities of ALGOL. In fact, all unsafe constructs are rejected by the NEWP compiler unless a block is specifically marked to allow those instructions. Such marking of blocks provide a multi-level protection mechanism. 757:. Early computers did not have enough memory to store the source code, so compilers (and even assemblers) usually needed to read the source code more than once. The Burroughs ALGOL syntax, unlike the official language, requires that each variable (or other object) be declared before it is used, so it is feasible to write an ALGOL compiler that reads the data only once. This concept has profound theoretical implications, but it also permits very fast compiling. Burroughs large systems could compile as fast as they could read the source code from the 2243:

they had the reverse problem, how to stop programs from being recursive. In the end they didn't bother. The Burroughs FORTRAN compiler allowed recursive calls (just as every other FORTRAN compiler does), but unlike many other computers, on a stack-based system the returns from such calls succeeded as well. This could have odd effects, as with a system for the formal manipulation of mathematical expressions whose central subroutines repeatedly invoked each other without ever returning: large jobs were ended by stack overflow!

2016:

D frame, which points to the frame containing the D environment. We then look at the control word at the base of this environment to find the D environment, and continue in this fashion until we have followed all the links back to the required lexical level. This is not the same path as the return path back through the procedures which have been called in order to get to this point. (The architecture keeps both the data stack and the call stack in the same structure, but uses control words to tell them apart.)

1593:

CP2000s were designed to provide network node support in a distributed network wherein the nodes were connected using the BNAV2 (Burroughs Network Architecture Version 2) networking technology. BNAV2 was a Burroughs functional equivalent of the IBM SNA product and did support interoperation with IBM environments in both PUT2 and PUT5 transport modes. The change in external datacommunications hardware did not require any change to existing MCS (Message Control System (discussed below)) software.

1610:

30 users per stack, in which case if you have 31 to 60 users, you have two stacks, 61 to 90 users, three stacks, etc. This gives B5000 machines a great performance advantage in a server since you don't need to start up another user process and thus create a new stack each time a user attaches to the system. Thus you can efficiently service users (whether they require state or not) with MCSs. MCSs also provide the backbone of large-scale transaction processing.

1623:

descriptions to generate DMALGOL code tailored for the tables and indexes specified. Administrators never need to write DMALGOL themselves. Normal user-level programs obtain database access by using code written in application languages, mainly ALGOL and COBOL, extended with database instructions and transaction processing directives. The most notable feature of DMALGOL is its preprocessing mechanisms to generate code for handling tables and indices.

881: 2180:

the development of "ragged" arrays, rather than the usual fixed rectangular (or higher dimension) arrays. Thus in two dimensions, a ragged array would have rows that were of different sizes. For instance, given a large array A of mostly-zero values, a sparse array representation that was declared as SA could have each row resized to have exactly enough elements to hold only the non-zero values of A along that row.

959:, followed by the B5500 and B5700. The first machines to replace the B5000 architecture were the B6500 and B7500. The successor machines to the B6500 and B7500 followed the hardware development trends to re-implement the architectures in new logic over the next 25 years, with the B6500, B7500, B6700, B7700, B6800, B7800, B5900, B7900 and finally the Burroughs A series. After a merger in which Burroughs acquired 4014: 1687:

the user stack. It turns off user process timers. The current process is placed in the appropriate queue for the resource being requested, or the ready queue waiting for the processor if this is a preemptive context switch. The operating system determines the first process in the ready queue and invokes the instruction move_stack, which makes the process at the head of the ready queue active.

2926: 2176:

array, possibly segmented if large enough, would then be accessed in the same manner as a single-dimensional array in ALGOL. Although accessing outside this array would be prevented, a wrong value for one index combined with a suitably wrong value for another index might not result in a bounds violation of the single sequence array; in other words, the indices were not checked individually.

1635:

database-specific if/then/else code at run-time. In the 1970s, this "tailoring" was used very extensively to reduce the code footprint and execution time. It became much less used in later years, partly because low-level fine tuning for memory and speed became less critical, and partly because eliminating the preprocessing made coding simpler and thus enabled more important optimizations.

917: 1725:— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — This is lexical level 2 (level zero is reserved for the operating system and level 1 for code segments). — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — At level 2 we place global variables for our program. 1699:. One way to increase system speed is to keep data as close to the processor as possible. In the B5000 stack, this was done by assigning the top two positions of the stack to two registers A and B. Most operations are performed on those two top of stack positions. On faster machines past the B5000, more of the stack may be kept in registers or cache near the processor. 2632:— Low-level semaphore operator: Load the A register with the memory location given by the A register and place the value in the B register at that memory location in a single uninterruptible cycle. The Algol compiler produced code to invoke this operator via a special function that enabled a "swap" operation on single-word data without an explicit temporary value. 944:, and the central concepts of descriptors and tagged architecture appeared in the design of the Rice Institute Computer in the late 1950s. However, even if those designs had a direct influence on Burroughs, the architectures of the B5000, B6500 and B8500 were very different from those of the Atlas and the Rice machine; they are also very different from each other. 2778:-based machines to the extent that MCP was the one and only control program, but the support provided by those machines is still inferior to that provided on the machines where the B6500 instruction set is the native instruction set. A little-known Intel processor architecture that actually preceded 32-bit implementations of the x86 instruction set, the 2184:

smaller individual segments in use were needed in memory. Actual storage for an array segment would be allocated at run time only if an element in that segment were accessed, and all elements of a created segment would be initialised to zero. Not initialising an array to zero at the start therefore was encouraged by this, normally an unwise omission.

977:. These machines were the Libra 100 through the Libra 500, with the Libra 590 being announced in 2005. Later Libras, including the 590, also incorporate Intel Xeon processors and can run the Burroughs large systems architecture in emulation as well as on the MCP CMOS processors. It is unclear if Unisys will continue development of new MCP CMOS ASICs. 1614:

functionality improvements. In the same general time frame an implementation of the OSI protocol stacks was made, principally on the CP2000, but a large supporting infrastructure was implemented on the main system. All of the OSI standard defined applications were implemented including X.400 mail hosting and X.500 directory services.

1597:

identified to handle traffic from the particular source device and return any response to the DCP for delivery to the destination device. From a processing perspective no changes were required to the MCS software to handle different types of gateway hardware, be it any of the 5 styles of DCP or the ICP or ICP/CP2000 combinations.

1912:

before the current position are visible at that part of the code, thus the requirement for forward declarations. All variables declared in enclosing blocks are visible. Another case is that variables of the same name may be declared in inner blocks and these effectively hide the outer variables which become inaccessible.

2496: 1884:— The declaration of a variable makes this a block, which will invoke some — stack building code. Normally you won't declare variables here, in which — case this would be a compound statement, not a block. ... <== sample stack is executing somewhere here. 2154:

to the wrong address could damage anything. Instead, the two-part address scheme was implemented by the hardware. At each lexical level, variables were placed at displacements up from the base of the level's stack, typically occupying one word - double precision or complex variables would occupy two. Arrays were

2247:

common causes of crashes. Similarly with the array-bound checking: programs that had been used for years on other systems embarrassingly often would fail when run on a Burroughs system. In fact, Burroughs became known for its superior compilers and implementation of languages, including the object-oriented

1585:

remote terminals. The DCP and the B6500 communicated by messages in memory, essentially packets in today's terms, and the MCS did the B6500-side processing of those messages. In the early years the DCP did have an assembler (Dacoma), an application program called DCPProgen written in B6500 ALGOL. Later the

2489:

call (VALC). Global routines are stored in the D environment as SIRWs that point to a PCW stored in the code segment dictionary in the D environment. The D environment is not stored on the current stack because it can be referenced by all processes sharing this code. Thus code is reentrant and shared.

3712:

Waychoff, Richard; Turner, Lloyd; Rosin, Robert F.; Pearson, Ralph W.; Oliphint, G. Clark; MacKenzie, F. Brad; MacDonald, Ray W.; MacDonald, Duncan N.; Lonergan, William D.; Kreuder, Norman L.; King, Paul D.; Hootman, Joseph T.; Hauck, Erwin A.; Hale, John E.; Galler, Bernard A.; Ford, James; Eppert,

2488:

Tag 7 is the program control word which describes a procedure entry point. When hardware operators hit a PCW, the procedure is entered. The ENTR operator explicitly enters a procedure (non-value-returning routine). Functions (value-returning routines) are implicitly entered by operators such as value

2242:

Another thing about the stack structure is that programs are implicitly recursive. FORTRAN was not expected to support recursion and perhaps one stumbling block to people's understanding of how ALGOL was to be implemented was how to implement recursion. On the B5000, this was not a problem – in fact,

2015:

Consider how we would access a lexical level 2 (D) global variable from lexical level 5 (D). Suppose the variable is 6 words away from the base of lexical level 2. It is thus represented by the address couple (2, 6). If we don't have D registers, we have to look at the control word at the base of the

1911:

Each stack frame corresponds to a lexical level in the current execution environment. As you can see, lexical level is the static textual nesting of a program, not the dynamic call nesting. The visibility rules of ALGOL, a language designed for single pass compilers, mean that only variables declared

1702:

Thus the designers of the current successors to the B5000 systems can optimize in whatever is the latest technique, and programmers do not have to adjust their code for it to run faster – they do not even need to recompile, thus protecting software investment. Some programs have been known to run for

1682:

Each stack and associated Program Reference Table (PRT) represents a process (task or thread) and tasks can become blocked waiting on resource requests (which includes waiting for a processor to run on if the task has been interrupted because of preemptive multitasking). User programs cannot issue an

1638:

An applications version of ALGOL to support the accessing of databases from application programs is called BDMSALGOL and included verbs like "FIND", "LOCK", "STORE", "GET", and "PUT" for database access and record manipulation. Additionally, the verbs "BEGINTRANSACTION" and "ENDTRANSACTION" were also

1609:

MCSs are items of software worth noting – they control user sessions and provide keeping track of user state without having to run per-user processes since a single MCS stack can be shared by many users. Load balancing can also be achieved at the MCS level. For example, saying that you want to handle

291:

The B5000 was unusual at the time in that the architecture and instruction set were designed with the needs of software taken into consideration. This was a large departure from the computer system design of the time, where a processor and its instruction set would be designed and then handed over to

2580:

depending on the kind of data being acted on as given by the tag. If we ignore the powerful string scanning, transfer, and edit operators, the basic set is only about 120 operators. If we remove the operators reserved for the operating system such as MVST and HALT, the set of operators commonly used

2183:

Because arrays larger than 1024 words were generally segmented but smaller arrays were not, on a system that was short of real memory, increasing the declared size of a collection of scratchpad arrays from 1,000 to say 1,050 could mean that the program would run with far less "thrashing" as only the

2175:

FORTRAN however regards all multidimensional arrays as being equivalent to a single-dimensional array of the same size, and for a multidimensional array simple integer arithmetic is used to calculate the offset where element A would be found in that single sequence. The single-dimensional equivalent

2171:

Arrays were not stored contiguous in memory with other variables, they were each granted their own address space, which was located via the descriptor. The access mechanism was to calculate on the stack the index variable (which therefore had the full integer range potential, not just fourteen bits)

2149:

Stack frames actually don't even have to exist in a process stack. This feature was used early on for file I/O optimization, the FIB (file information block) was linked into the display registers at D during I/O operations. In the early nineties, this ability was implemented as a language feature as

2019:

As you can see, this is quite inefficient just to access a variable. With D registers, the D register points at the base of the lexical level 2 environment, and all we need to do to generate the address of the variable is to add its offset from the stack frame base to the frame base address in the D

2011:

A stack hardware optimization is the provision of D (or "display") registers. These are registers that point to the start of each called stack frame. These registers are updated automatically as procedures are entered and exited and are not accessible by any software other than the MCP. There are 32

1706:

Another point for speed as promoted by the RISC designers was that processor speed is considerably faster if everything is on a single chip. It was a valid point in the 1970s when more complex architectures such as the B5000 required too many transistors to fit on a single chip. However, this is not

1686:

So a process switch proceeds something like this – a process requests a resource that is not immediately available, maybe a read of a record of a file from a block which is not currently in memory, or the system timer has triggered an interrupt. The operating system code is entered and run on top of

1658:

In many early systems and languages, programmers were often told not to make their routines too small. Procedure calls and returns were expensive, because a number of operations had to be performed to maintain the stack. The B5000 was designed as a stack machine – all program data except for arrays

1571:

NEWP programs that contain unsafe constructs are initially non-executable. The security administrator of a system is able to "bless" such programs and make them executable, but normal users are not able to do this. (Even "privileged users", who normally have essentially root privilege, may be unable

741:

on an earlier Burroughs machine during the three months of his summer break, and he was peripherally involved in the B5000 design as a consultant. Many wrote ALGOL off, mistakenly believing that high-level languages could not have the same power as assembler, and thus not realizing ALGOL's potential

625:

For Operand Call (OPDC) and Descriptor Call (DESC) syllables, the relative address is bits 0-9 (T register) of the syllable. For Store operators (CID, CND, ISD, ISN, STD, STN), the A register (top of stack) contains an absolute address if the Flag bit is set and a relative address if the Flag bit is

158:

as one of the architectures that he admires the most. "I always thought it was one of the most innovative examples of combined hardware/software design I've seen, and far ahead of its time." The B5000 was succeeded by the B5500, which used disks rather than drum storage, and the B5700, which allowed

2770:

Another facet of the B5000 architecture was that it was a secure architecture that runs directly on hardware. This technique has descendants in the virtual machines of today in their attempts to provide secure environments. One notable such product is the Java JVM which provides a secure sandbox in

2660:

The direct influence of the B5000 can be seen in the current Unisys ClearPath range of mainframes which are the direct descendants of the B6500, which was influenced by the B5000, and still have the MCP operating system after 40 years of consistent development. This architecture is now called emode

2223:

The Data Descriptor generated at compilation time indicated the data type usage for which the array was intended. If an array equivalence declaration was made a copy descriptor indicating that particular usage type was generated but pointed back to the original, or MOM, descriptor. Thus, indexing

2179:

Because an array's storage was not bounded on each side by storage for other items, it was easy for the system to "resize" an array - though changing the number of dimensions was precluded because compilers required all references to have the same number of dimensions. In ALGOL's case, this enabled

2162:

Much more important is that this method meant that many errors possible on systems employing flat addressing could not occur because they were simply unspeakable even at the machine code level. A task had no way to corrupt memory in use by another task, because it had no way to develop its address.

2153:

On other systems, the compiler might build its symbol table in a similar manner, but eventually the storage requirements would be collated and the machine code would be written to use flat memory addresses of 16-bits or 32-bits or even 64-bits. These addresses might contain anything so that a write

2141:

If we had invoked the procedure p as a coroutine, or a process instruction, the D environment would have become a separate D-based stack. This means that asynchronous processes still have access to the D environment as implied in ALGOL program code. Taking this one step further, a totally different

1915:

Lexical nesting is static, unrelated to execution nesting with recursion, etc. so it is very rare to find a procedure nested more than five levels deep, and it could be argued that such programs would be poorly structured. B5000 machines allow nesting of up to 32 levels. This could cause difficulty

1613:

Around 1988 an implementation of TCP/IP was developed principally for a U.S. government customer utilizing the CP2000 distributed communications processor as the protocol host. Two to three years later, the TCP/IP implementation was rewritten to be host/server based with significant performance and

1584:

In the original implementation, the system used an attached specialized data communications processor (DCP) to handle the input and output of messages from/to remote devices. This was a 24-bit minicomputer with a conventional register architecture and hardware I/O capability to handle thousands of

1547:

The user level of ALGOL does not include many of the insecure constructs needed by the operating system and other system software. Two levels of language extensions provide the additional constructs: ESPOL and NEWP for writing the MCP and closely related software, and DCALGOL and DMALGOL to provide

769: 2751:

in the late 1970s and early 1980s were also 16-bit stack machines, influenced by the B5000 indirectly through the HP 3000 connection, as several of the early Tandem engineers were formerly with HP. Around 1990, these systems migrated to MIPS RISC architecture but continued to support execution of

2473:

Tag 1 words represent on-stack data addresses. The normal IRW simply stores an address couple to data on the current stack. The SIRW references data on any stack by including a stack number in the address. Amongst other things, SIRW's are used to provide addressing between discrete process stacks

1950:

mechanism invokes a procedure as an asynchronous task with a separate stack set up starting at the lexical level of the processed procedure. As an asynchronous task, there is no control over exactly when control will be passed between the tasks, unlike coroutines. The processed procedure still has

1605:

program and is written in DCALGOL (Data Communications ALGOL). As stated above, the MCS received messages from queues maintained by the Datacom Control Stack (DCC) and forwarded these messages to the appropriate application/function for processing. One of the original MCS's was CANDE (Command AND

1592:

Starting in the early 1980's, the DCP technology was replaced by the ICP (Integrated Communications Processor) which provided LAN based connectivity for the mainframe system. Remote devices, and remote servers/mainframes, were connected to the network via freestanding devices called CP2000s. The

1575:

NEWP has a number of facilities to enable large-scale software projects, such as the operating system, including named interfaces (functions and data), groups of interfaces, modules, and super-modules. Modules group data and functions together, allowing easy access to the data as global within the

295:

The B5000, B5500 and B5700 in Word Mode has two different addressing modes, depending on whether it is executing a main program (SALF off) or a subroutine (SALF on). For a main program, the T field of an Operand Call or Descriptor Call syllable is relative to the Program Reference Table (PRT). For

2469:

Even-tagged words are user data which can be modified by a user program as user state. Odd-tagged words are created and used directly by the hardware and represent a program's execution state. Since these words are created and consumed by specific instructions or the hardware, the exact format of

2246:

Thus Burroughs FORTRAN had better error checking than other contemporary implementation of FORTRAN. For instance, for subroutines and functions it checked that they were invoked with the correct number of parameters, as is normal for ALGOL-style compilers. On other computers, such mismatches were

113:

Burroughs' first internally developed machine, the B5000, was designed in 1961 and Burroughs sought to address its late entry in the market with the strategy of a completely different design based on the most advanced computing ideas available at the time. While the B5000 architecture is dead, it

2293:

Later, when the B6500 was designed, it was realized that the 1-bit control word/numeric distinction was a powerful idea and this was extended to three bits outside of the 48 bit word into a tag. The data bits are bits 0–47 and the tag is in bits 48–50. Bit 48 was the read-only bit, thus odd tags

2158:

stored in this area, only a one word descriptor for the array was. Thus, at each lexical level the total storage requirement was not great: dozens, hundreds or a few thousand in extreme cases, certainly not a count requiring 32-bits or more. And indeed, this was reflected in the form of the VALC

61:

was organized into three divisions with very different product line architectures for high-end, mid-range, and entry-level business computer systems. Each division's product line grew from a different concept for how to optimize a computer's instruction set for particular programming languages.

1622:

Another variant of ALGOL is DMALGOL (Data Management ALGOL). DMALGOL is ALGOL extended for compiling the DMSII database software from database description files created by the DASDL (Data Access and Structure Definition Language) compiler. Database designers and administrators compile database

1596:

On input, messages were passed from the DCP via an internal bus to the relevant MCP Datacom Control (DCC) DCP process stack. One DCC process was initiated for each DCP configured on the system. The DCP Process stack would then ensure that the inbound message was queued for delivery to the MCS

2020:

register. (There is an efficient linked list search operator LLLU, which could search the stack in the above fashion, but the D register approach is still going to be faster.) With D registers, access to entities in outer and global environments is just as efficient as local variable access.

1634:

databases. After a database is defined using the Data Access and Structure Definition Language (DASDL), the schema is translated by the preprocessor into tailored DMALGOL access routines and then compiled. This means that, unlike in other DBMS implementations, there is often no need for

1938:

mechanism invokes a procedure as a coroutine. Coroutines are partner tasks established as synchronous entities operating in their own stack at the same lexical level as the initiating process. Control is explicitly passed between the initiating process and the coroutine by means of a

2150:

STRUCTURE BLOCKs and – combined with library technology - as CONNECTION BLOCKs. The ability to link a data structure into the display register address scope implemented object orientation. Thus, the B6500 actually used a form of object orientation long before the term was ever used.

53:

programs extremely well, using single-pass compilers. The B5000 evolved into the B5500 (disk rather than drum) and the B5700 (up to four systems running as a cluster). Subsequent major redesigns include the B6500/B6700 line and its successors, as well as the separate B8500 line.

2593:

The B5000 line also were pioneers in having two processors connected together on a high-speed bus as master and slave. In the B6000, B7000 and B8000 lines the processors were symmetric. The B7000 line could have up to eight processors, as long as at least one was an I/O module.

1600:

Apart from being a message delivery service, an MCS is an intermediate level of security between operating system code (in NEWP) and user programs (in ALGOL, or other application languages including COBOL, FORTRAN, and, in later days, JAVA). An MCS may be considered to be a

2187:

Array equivalencing is also supported. The ARRAY declaration requested allocation of 48-bit data words which could be used to store any bit pattern but the general operational practice was that each allocated word was considered to be a REAL operand. The declaration of:

1963:. This runs a procedure as an independent task which can continue on after the originating process terminates. For this reason, the child process cannot access variables in the parent's environment, and all parameters passed to the invoked procedure must be call-by-value. 2238:

One nice thing about the stack structure is that if a program does happen to fail, a stack dump is taken and it is very easy for a programmer to find out exactly what the state of a running program was. Compare that to core dumps and exchange packages of other systems.

868:. The architecture employed a 48-bit word, stack, and descriptors like the B5500, but was not advertised as being upward-compatible. The B8500 could never be gotten to work reliably, and the project was canceled after 1970, never having delivered a completed system. 2731:

business system had used a B5500 and were greatly impressed by its hardware and software; they aimed to build a 16-bit minicomputer with similar software. Several other HP divisions created similar minicomputer or microprocessor stack machines. Bob Barton's work on

1534:

While B5000 was specifically designed to support ALGOL, this was only a starting point. Other business-oriented languages such as COBOL were also well supported, most notably by the powerful string operators which were included for the development of fast compilers.

1649:

In later years, with compiler code size being less of a concern, most of the preprocessing constructs were made available in the user level of ALGOL. Only the unsafe constructs and the direct processing of the database description file remain restricted to DMALGOL.

764:

The powerful Burroughs COBOL compiler was also a one-pass compiler and equally fast. A 4000-card COBOL program compiled as fast as the 1000-card/minute readers could read the code. The program was ready to use as soon as the cards went through the reader.

793:

The B6500 (delivery in 1969) and B7500 were the first computers in the only line of Burroughs systems to survive to the present day. While they were inspired by the B5000, they had a totally new architecture. Among the most important differences were

2289:

In the original B5000, a flag bit in each control or numeric word was set aside to identify the word as a control word or numeric word. This was partially a security mechanism to stop programs from being able to corrupt control words on the stack.

2145:

The D and D environments do not occur in the current process's stack. The D environment is the code segment dictionary, which is shared by all processes running the same code. The D environment represents entities exported by the operating system.

2002:

In the example program only normal calls are used, so all the information will be on a single stack. For asynchronous calls, a separate stack is initiated for each asynchronous process so that the processes share data but run asynchronously.

1710:

In fact, the A Series line of B5000 successors included the first single chip mainframe, the Micro-A of the late 1980s. This "mainframe" chip (named SCAMP for Single-Chip A-series Mainframe Processor) sat on an Intel-based plug-in PC board.

1538:

The ALGOL used on the B5000 is an extended ALGOL subset. It includes powerful string manipulation instructions but excludes certain ALGOL constructs, notably unspecified formal parameters. A DEFINE mechanism serves a similar purpose to the

1572:

to do this depending on the configuration chosen by the site.) While NEWP can be used to write general programs and has a number of features designed for large software projects, it does not support everything ALGOL does.

924:

In the following discussion, the machine designations, B5000, A Series, and ClearPath/MCP are used interchangeably although this needlessly conflates the features and concepts of the B5000 and B8500 lines with the B6500

3596: 2194:

requested the allocation of 100 words of type REAL data space in memory. The programmer could also specify that the memory might be referred to as character oriented data by the following equivalence declaration:

2219:

requested that the system allocated a 100 character array. Given that the architecture is word based, the actual space allocated is the requested number of characters rounded up to the next whole word boundary.

1875:— — — — — — — — — — — — — — — — — — — — — — — — — — — — — A variable declared here makes this lexical level 4 — — — — — — — — — — — — — — — — — — — — — — — — — — — — 2470:

these words can change between hardware implementation and user programs do not need to be recompiled, since the same code stream will produce the same results, even though system word format may have changed.

1626:

DMALGOL preprocessing includes variables and loops, and can generate names based on compile-time variables. This enables tailoring far beyond what can be done by preprocessing facilities which lack loops.

1543:

found in C, but is fully integrated into the language rather than being a preprocessor. The EVENT data type facilitates coordination between processes, and ON FAULT blocks enable handling program faults.

1659:(which include strings and objects) was kept on the stack. This meant that stack operations were optimized for efficiency. As a stack-oriented machine, there are no programmer addressable registers. 2270:

The storage required for the multiple processes came from the system's memory pool as needed. There was no need to do SYSGENs on Burroughs systems as with competing systems in order to preconfigure

2610:

data type did have some system overhead. To avoid this overhead, a special locking technique called Dahm locks (named after a Burroughs software guru, Dave Dahm) can be used. Dahm locks used the

2466:

The current incarnation of these machines, the Unisys ClearPath has extended tags further into a four bit tag. The microcode level that specified four bit tags was referred to as level Gamma.

749:

when he submitted a program to be compiled at the B5000 Pasadena plant. His deck of cards was compiled almost immediately and he immediately wanted several machines for his university,

3727: 2267:

disagreed, since LISP was based on modifiable code, he did not like the unmodifiable code of the B5000, but most LISP implementations would run in an interpretive environment anyway.

2669:

instruction set as the native instruction set, with code running on those processors emulating the B5000 instruction set. In those machines, there was also going to be an nmode (

1564:. Though NEWP probably just meant "New Programming language", legends surround the name. A common (perhaps apocryphal) story within Burroughs at the time suggested it came from " 159:

multiple CPUs to be clustered around shared disk. While there was no successor to the B5700, the B5000 line heavily influenced the design of the B6500, and Burroughs ported the

142:

operating systems on their Libra servers; the use of custom chips was gradually eliminated, and by 2018 the Libra servers had been strictly commodity Intel for some years.

4181: 3726:

The Burroughs 5000 computer series is discussed by individuals responsible for its development and marketing from 1957 through the 1960s in a 1985 conference sponsored by

3600: 3907: 3825: 2230:

The immediately preceding discussion uses the ALGOL syntax implementation to describe ARRAY declarations, but the same functionality is supported in COBOL and FORTRAN.

86:

was founded before Burroughs, but did not make computing devices in the 19th century). By the late 1950s its computing equipment was still limited to electromechanical

1916:

for some systems that generated Algol source as output (tailored to solve some special problem) if the generation method frequently nested procedure within procedure.

2763:. Kay was also impressed by the data-driven tagged architecture of the B5000 and this influenced his thinking in his developments in object-oriented programming and 4201: 2704:. The first two generations of the series featured tagged memory and stack-based CPUs that were programmed only in high-level languages. There existed a kind of an 2282:

The most defining aspect of the B5000 is that it is a stack machine as treated above. However, two other very important features of the architecture is that it is

1707:

the case today and every B5000 successor machine now fits on a single chip as well as the performance support techniques such as caches and instruction pipelines.

1695:

Stack performance was considered to be slow compared to register-based architectures, for example, such an architecture had been considered and rejected for the

3760: 3094: 3739: 710:. FORTRAN and COBOL were considered weaker languages by some, when it comes to modern software techniques, so a newer, mostly untried language was adopted, 1858:

be a — coding mistake. Some few of ALGOL's successors therefore insist that — value parameters be read only – but most do not.

1557: 1511: 200: 1931:

invocation invokes a procedure in the normal way any language invokes a routine, by suspending the calling routine until the invoked procedure returns.

242:: programmers don't have to do anything more to have any code in any language spread across processors than to use just the two shown simple primitives. 2294:

indicated control words that could not be written by a user-level program. Code words were given tag 3. Here is a list of the tags and their function:

2713: 2712:

and supported structured programming and first-class procedures. Later generations of the series, though, switched away from this architecture to the

726:. This was a practical extension of ALGOL with I/O instructions (which ALGOL had ignored) and powerful string processing instructions. Hoare's famous 3366:

Anderson, James P.; Hoffman, Samuel A.; Shifman, Joseph; Williams, Robert J. (1962), "D825 - a multiple-computer system for command & control",

2943: 3996: 974: 3854: 122:

operating system first introduced with the B6700. The third and largest line, the B8500, had no commercial success. In addition to a proprietary

4176: 702:

The B5000 was designed to exclusively support high-level languages. This was at a time when such languages were just coming to prominence with

3278: 2271: 1160:

B6000 class, First pipelined processor in the mid-range, single CPU (dual on A10), First to support eMode Beta (expanded Memory Addressing)

2693:, Moore described the influence, noting that Forth's DUP, DROP and SWAP came from the corresponding B5500 instructions (DUPL, DLET, EXCH). 2563: 788: 3157: 3565:"Unisys Accelerates Mainframe Rebirth with New ClearPath Enterprise Servers, Aggressive New Pricing. - Business Wire - HighBeam Research" 2492:

Tag 3 represents code words themselves, which won't occur on the stack. Tag 3 is also used for the stack control words MSCW, RCW, TOSCW.

3630: 2572:, which may be Name Call, Value Call, or form an operator, which may be from one to twelve syllables in length. There are less than 200 2522: 1403: 211: 83: 3433: 2990: 2260: 1787:— — — — — — — — — — — — — — — — — — — This block is at lexical level 3 — — — — — — — — — — — — — — — — — — 750: 3713:

Ray R.; Dent, Benjamin A.; Dahm, David M.; Creech, Bobby A.; Collins, George A.; Berce, Henri; Barton, Robert S. (6 September 1985).

3180: 3121: 4191: 3638: 3383: 3328: 3009: 2962: 3344: 4096: 3951: 3201: 2485:

Tag 5 words are descriptors, which are more fully described in the next section. Tag 5 words represent off-stack data addresses.

3223: 296:

subroutines, the type of addressing is dependent on the high three bits of T and on the Mark Stack FlipFlop (MSFF), as shown in

3892: 2969: 2577: 2573: 2138:| (2, 0) The Mark Stack Control Word containing the link to the previous stack frame. |=======================| — Stack bottom 1146:

1-2 HDUs (I/O), 1-2 APs, 1-4 CPUs, Soft implementation of NUMA memory allowed CPUs to float from memory space to memory space.

180: 3979: 3406: 2947: 3924: 3564: 3839: 2976: 2684: 1359: 3245: 2752:

stack machine binaries by object code translation or direct emulation. Sometime after 2000, these systems migrated to

2514:

The figure to the left shows how the Burroughs Large System architecture was fundamentally a hardware architecture for

860:

The B8500 was designed in the 1960s as an attempt to merge the B5500 and the D825 designs. The system used monolithic

114:

inspired the B6500 (and subsequent B6700 and B7700). Computers using that architecture were still in production as the

4216: 4211: 4206: 3897: 2810: 2649: 2515: 1986:

to save the overhead of a procedure call; this is best done for small pieces of code. Inline functions are similar to

1586: 1576:

module. Interfaces allow a module to import and export functions and data. Super-modules allow modules to be grouped.

276: 3772: 3106: 2459:

Internally, some of the machines had 60 bit words, with the extra bits being used for engineering purposes such as a

1966:

Thus, Burroughs Extended ALGOL had some of the multi-processing and synchronization features of later languages like

3751: 3289:(film), Nigel Williams (published 2015-08-08), Timecode: 1969 status - 0:00-0:52, 6:04-7:01, 8:14; date - 3:40, 4:21 2958: 2648:

Two processors could infrequently simultaneously send each other a 'HEYU' command resulting in a lockup known as 'a

3492: 3065: 2673:), but this was dropped, so you may often hear the B6500 successor machines being referred to as "emode machines". 2256: 1967: 257: 2936: 1665:

is also very efficient on the B5000 and B6500 lines. There are specific instruction to perform process switches:

150:

The first member of the first series, the B5000, was designed beginning in 1961 by a team under the leadership of

4221: 3719: 3497: 2774:

The value of the hardware-architecture binding that existed before emode would be substantially preserved in the

2688: 1560:(Executive Systems Programming Oriented Language). This was replaced in the mid-to-late 70s by a language called 1363: 1347: 1141: 1124: 1107: 1077: 816: 4071: 2795: 1991: 1375: 223:

where all operations use the stack rather than explicit operands. This approach has by now fallen out of favor.

67: 1639:

implemented to solve the deadlock situation when multiple processes accessed and updated the same structures.

4186: 4124: 4040: 3986: 2800: 2733: 1371: 1063:

faster processor, cache for stack, up to 8 requestors (I/O or Central processors) in one or two partitions.

941: 107: 71: 687:(current instruction word)-relative forced to R (PRT)-relative for Store, Program and I/O Release operators 62:"Burroughs Large Systems" referred to all of these large-system product lines together, in contrast to the 3901: 3262: 2227:

BOOLEAN arrays are also supported and may be used as a bit vector. INTEGER arrays may also be requested.

1415: 1411: 1407: 1346:

Hardware and software design, development, and manufacturing were split between two primary locations, in

239: 3799: 3582: 3974: 3731: 2696:

B5000 machines with their stack-based architecture and tagged memory also heavily influenced the Soviet

2545: 2532:

There are three distinct instruction sets for the Burroughs large systems. All three are based on short

1662: 1447: 1174: 753:

in the Netherlands. The compiler was fast for several reasons, but the primary reason was that it was a

266:

An attempt at a secure architecture prohibiting unauthorized access of data or disruptions to operations

58: 2786:

have provided an equivalent physical basis, as it too was essentially an object-oriented architecture.

1093:

semiconductor memory, faster, up to 8 requestors (I/O or Central processors) in one or two partitions.

3301: 2082:| (3, 0) The Mark Stack Control Word containing the link to D. |=======================| | 1 | 2038:| (4, 0) The Mark Stack Control Word containing the link to D. |=======================| | 0 | 4106: 3944: 2983: 2822: 2551: 1398: 1355: 956: 91: 46: 2585:; the Operator syllables either use no addresses or use control words and descriptors on the stack. 3153: 2283: 1987: 952: 948: 810: 207: 151: 2602:

operates in a single cycle. The higher level mechanism generally employed by user programs is the

2213:

The capability to request data type specific arrays without equivalencing is also supported, e.g.

3991: 3389: 3274: 3141: 2816: 2252: 1528: 1472: 1442: 1367: 960: 861: 838: 87: 38: 3544: 1556:

Originally, the B5000 MCP operating system was written in an extension of extended ALGOL called

4150: 3634: 3410: 3379: 3324: 2876:

Despite the model number, the B5900 had a B6500 architecture rather than a B5000 architecture.

2705: 2697: 2661:(for emulation mode) since the B6500 architecture has been implemented on machines built from 754: 192: 135: 3039: 1127:

architecture. Max of 4 B5900 CPUs bound to a local memory and a common Global Memory II (tm)

849:

Among other customers of the B6700 and B7700 were all five New Zealand universities in 1971.

4145: 3821: 3807: 3785: 3700: 3667: 3371: 3145: 2748: 2680: 1983: 1482: 865: 842: 246: 82:

Founded in the 1880s, Burroughs was the oldest continuously operating company in computing (

35: 3695:

Barton, Robert S. (1961). "A New Approach to the Functional Design of a Digital Computer".

2676:

B5000 machines were programmed exclusively in high-level languages; there is no assembler.

1970:. It made use of the support for asynchronous processes that was built into the hardware. 1362:, where it developed the B6500. The Orange County location, which was based in a plant in 49:. The first machine in the family was the B5000 in 1961, which was optimized for compiling 4196: 4129: 4061: 3937: 3622: 2842: 2724: 2501: 1683:

IP1, IP2 or MVST, and there is only one place in the operating system where this is done.

1432: 857:

The B8500 line derives from the D825, a military computer that was inspired by the B5000.

822: 803: 774: 746: 261: 186: 99: 3913: 1703:

years over many processor upgrades. Such speed up is limited on register-based machines.

1110:

architecture. Max of 4 B6900 CPUs bound to a local memory and a common Global Memory(tm)

2581:

by user-level programs is less than 100. The Name Call and Value Call syllables contain

1994:#defines, except you don't get the problems with parameters that you can with macros. 1374:, was responsible for the smaller B6x00 line, while the East Coast operations, based in 4001: 3871:, Society for the History of Technology Annual Meeting, 20 Sep-3 Oct 2010, Tacoma, USA. 3044: 2846: 2779: 2737: 2569: 2034:(declared on entry to a block, not a procedure) |-----------------------| | D==>3 | 1540: 1354:. The initial Large Systems Plant, which developed the B5000 and B5500, was located in 937: 933: 799: 719: 17: 880: 745:

The Burroughs ALGOL compiler was very fast — this impressed the Dutch scientist

4170: 4155: 4066: 4035: 3655: 3450: 2701: 1515: 1487: 715: 250: 220: 160: 131: 119: 42: 3869:"'Too far ahead of its time': Britain, Burroughs and real-time banking in the 1960s" 3471: 3393: 3209:. Systems Documentation. Burroughs Corporation. May 1967. p. 5-4. 1021326. 2460: 1643: 1631: 1351: 947:

The first of the Burroughs large systems was the B5000. Designed in 1961, it was a

758: 734: 727: 3417: 3921:

Project to create a functional emulator for the Burroughs B5500 computer system.

3861:"The Burroughs B5900 and E-Mode A bridge to 21st Century Computing Revised 2018" 3568: 2925: 2717: 2670: 723: 155: 154:. It had an unusual architecture. It has been listed by the computing scientist 4013: 3846: 3149: 4022: 3284: 2662: 2598:(ReaD with LocK) is a very low-level way of synchronizing between processors. 2012:

D registers, which is what limits operations to 32 levels of lexical nesting.

1696: 1602: 1178: 203:. However, ESPOL had statements for each of the syllables in the architecture. 102:, who had started to produce larger-scale computers, or with recently founded 3886: 3860: 3812: 3790: 3704: 3375: 2764: 2533: 3881: 2317:

All kinds of user and system data (text data and single precision numbers)

118:

ClearPath Libra servers which run an evolved but compatible version of the

3520: 2259:

declared that the Burroughs implementation of APL was the best he'd seen.

4091: 4086: 3123:

The Operational Characteristics of the Processors for the Burroughs B5000

2760: 2709: 1924:

Procedures can be invoked in four ways – normal, call, process, and run.

1499: 738: 711: 273: 196: 50: 4045: 3671: 2753: 2728: 703: 2495: 2134:| (2, 1) A return control word |-----------------------| | D==>3 | 2078:| (3, 1) A return control word |-----------------------| | D==>3 | 809:

The B6500 had a 51-bit instead of a 48-bit word, and used 3 bits as a

4116: 4081: 3960: 3368:

Proceedings of the December 4–6, 1962, Fall Joint Computer Conference

2756:

architecture and continued to run the legacy stack machine binaries.

2576:, all of which fit into 8-bit syllables. Many of these operators are 2248: 1783:; — p1 passed by value, p2 implicitly passed by reference. 964: 115: 103: 3918: 2518:, something that still doesn't exist in conventional architectures. 269:

Early error-detection supporting development and testing of software

195:

or assembler; all system software written in an extended variety of

3545:"Unisys Clears the Path Ahead for A & OS 2200 Series Customers" 979: 4076: 3887:

The Burroughs B5900 and E-Mode: A bridge to 21st Century Computing

3246:"Historical Narrative The 1960s; US vs IBM, Exhibit 14971, Part 2" 2805: 2741: 2708:

for them, called El-76, but it was more or less a modification of

2494: 2463:

error-correction field, but these were never seen by programmers.

1425: 1387: 1024:

3rd generation computer (integrated circuits), up to 4 processors

767: 707: 230: 139: 63: 3868: 1978:

One last possibility is that in NEWP a procedure may be declared

272:

A commercial implementation virtual memory, preceded only by the

4101: 3893:(web archive of:) Ralph Klimek on the B7800 at Monash University 3303:

burroughs :: B6500 6700 :: CUBE XVI B6500 Status Apr70

2908:

There was no flag bit in words containing character data or code

2264: 1561: 1548:

more specific extensions for specific kinds of system software.

1519: 1241: 970: 834:

to allow nested subroutines to access variables in outer blocks.

768: 127: 123: 3933: 3203:

Burroughs B5500 Information Processing Systems Reference Manual

3370:, AFIPS Conference Proceedings, vol. 24, pp. 86–96, 3225:

Burroughs B6500 Information Processing System Reference Manual

3182:

Burroughs B5500 Information Processing System Reference Manual

2919: 2775: 2666: 2023:

D Tag Data — Address couple, Comments register

1719:

Here is an example of how programs map to the stack structure

910: 875: 95: 3714: 967:, the company continued to develop new machines based on the 3929: 761:, and they had the fastest card readers in the industry. 2201:

or as hexadecimal data via the equivalence declaration:

1642:

Roy Guck of Burroughs was one of the main developers of

1630:

DMALGOL is used to provide tailored access routines for

1173:

B7000 class, Re-implemented in custom-designed Motorola

94:. It had nothing to compete with its traditional rivals 3654:

G. M. Amdahl; G. A. Blaauw; F. P. Brooks (April 1964).

892: 70:(B2000, B3000, and B4000) or the flexible-architecture 3784:. Spring Joint Computer Conference. pp. 245–251. 2224:

the correct location in memory was always guaranteed.

1240:

Implements Burroughs Large systems in emulation only (

1201:

desktop "mainframe" with single-chip SCAMP processor.

1140:

semiconductor memory, faster, code & data caches,

733:

Thus the B5000 was based on a very powerful language.

176:

Hardware was designed to support software requirements

3043:

B5500, B6500, B6700, B6800, B6900, B7700 manuals at:

2499:

Figure 9.2 From the ACM Monograph in the References.

1181:, single CPU single HDU (A12) 1–4 CPU, 1–2 HDU (A15) 998:

initial system, 2nd generation (transistor) computer

772:

Figure 4.5 From the ACM Monograph in the References.

3806:. Fall Joint Computer Conference. pp. 413–417. 3697:

Proceedings of the Western Joint Computer Conference

2550:

Programs on a B5000, B5500 and B5700 are made up of

1527:

The Burroughs large systems implement ALGOL-derived

4138: 4115: 4054: 4021: 3967: 3827:

Computer System Organization The B5700/B6700 series

2950:. Unsourced material may be challenged and removed. 2359:Software Control Word (used to cut back the stack) 1982:, that is when the compiler sees a reference to it 1505: 1493: 1481: 1471: 1453: 1441: 1431: 1421: 1397: 798:The B6500 had variable length instructions with an 2207:or as ASCII data via the equivalence declaration: 2090:======> |-----------------------| | 0 | 3252:. US Government. July 22, 1980. p. 648 (409) 27:Range of mainframe computers in the 1960s and 70s 3840:"Stories of the B5000 and People Who Were There" 2062:at (2,6) |-----------------------| | 0 | 226:All interrupts and procedure calls use the stack 1984:the code for the procedure is generated inline 1846:— Since this overwrites the original value of 1531:. The B5000 was the first stack-based system. 3945: 3567:(Press release). June 8, 1998. Archived from 3515: 3513: 3088: 3086: 3084: 3082: 3030:Computer Architecture: A Structured Approach, 2687:, who encountered the B5500 while at MIT. In 714:. The ALGOL dialect chosen for the B5000 was 8: 3240: 3238: 1392: 802:instead of fixed length instructions with a 3539: 3537: 3493:"Unisys Ready To Offer A Desktop Mainframe" 3218: 3216: 2683:, the designer of the programming language 2614:ALGOL language statement which generated a 2474:such as those generated in response to the 1366:but at times included facilities in nearby 4012: 3952: 3938: 3930: 3411:"Chapter 2 Early Descriptor Architectures" 3345:"Computing History Displays: Fourth Floor" 3174: 3172: 2740:beginning with the 9100A, and notably the 1391: 4182:High-level language computer architecture 3811: 3789: 3010:Learn how and when to remove this message 1580:DCALGOL and Message Control Systems (MCS) 179:Hardware designed to exclusively support 126:processor design, Unisys also uses Intel 3838:Waychoff, Richard (September 27, 1979). 3059: 3057: 3055: 2886: 2884: 2882: 2759:Bob Barton was also very influential on 2627:— send an interrupt to another processor 2296: 302: 3925:"Burroughs B6500 film & transcript" 3660:IBM Journal of Research and Development 3472:"SCAMP picture at dave's Old computers" 3200:"Table 5-1 Relative Addressing Table". 3051: 2834: 2130:|-----------------------| | 3 | 2122:|-----------------------| | 0 | 2114:|-----------------------| | 0 | 2106:|-----------------------| | 0 | 2098:|-----------------------| | 0 | 2074:|-----------------------| | 3 | 2054:|-----------------------| | 1 | 2046:|-----------------------| | 0 | 1672:Initiate P1 (IP1) and Initiate P2 (IP2) 653: 651: 649: 647: 594: 297: 4202:Computer-related introductions in 1961 3761:"Burroughs Third-Generation Computers" 3599:. Unisys. 24 June 2021. Archived from 3451:"Daves Old Computers - Other Machines" 3321:Computer Architecture and Organization 3095:"Burroughs Third-Generation Computers" 2679:The B5000 stack architecture inspired 2645:— Idle until an interrupt is received 668: 666: 634: 632: 588: 110:and rebranded its design as the B205. 3782:Burroughs B6500/B7500 Stack Mechanism 3740:"Some Burroughs Transistor Computers" 3491:Reitman, Valerie (January 18, 1989), 539:Address of last RCW or MSCW on stack 437:Address of last RCW or MSCW on stack 7: 3656:"Architecture of the IBM System/360" 3299:Shipments rate, first 16 computers: 3231:, Burroughs, September 1969, 1043676 3142:"Admired designs / designs to study" 2948:adding citations to reliable sources 2899:Only for B6500, B7500 and successors 2564:Burroughs B6x00-7x00 instruction set 789:Burroughs B6x00-7x00 instruction set 718:, first designed and implemented by 505:Address of current instruction word 229:Support for other languages such as 3997:Eckert–Mauchly Computer Corporation 3026:(Three Volumes), Donald J. Gregory. 2523:Burroughs large systems descriptors 742:as a systems programming language. 217:Few programmer accessible registers 4102:New Executive Programming Language 3780:Hauck, E.A.; Dent, Ben A. (1968). 2582: 783:B6500, B6700/B7700, and successors 751:Eindhoven University of Technology 25: 3804:Language Directed Computer Design 3715:"The Burroughs B 5000 Conference" 3419:Capability-Based Computer Systems 3038:Philip J. Koopman, available at: 3032:R. Doran, Academic Press (1979). 2924: 2747:The NonStop systems designed by 2380:Stuffed Indirect Reference Word 2339:Step Index word (used in loops) 1566:No Executive Washroom Privileges 915: 879: 181:high-level programming languages 2935:needs additional citations for 2890:Only for B5000, B5500 and B5700 936:appeared in the designs of the 817:Symmetric Multiprocessing (SMP) 3980:System Development Corporation 3908:"Computer System Organization" 3283:Burroughs Corporation (1969), 3036:Stack Computers: The New Wave, 2736:(RPN) also found its way into 832:Display Registers, D1 thru D32 573:F register from MSCW at PRT+7 471:F register from MSCW at PRT+7 1: 4177:Burroughs mainframe computers 3759:Gray, George (October 1999). 3439:. Burroughs. August 11, 1964. 3286:Burroughs B6500 Status Report 3064:John T. Lynch (August 1965), 2510:Descriptor-based architecture 2058:| (3, 3) A SIRW reference to 1715:How programs map to the stack 730:lecture was on this subject. 32:Burroughs Large Systems Group 3627:Computer System Organization 3093:George Gray (October 1999), 2744:and subsequent calculators. 2618:operator at the code level. 2536:that fit evenly into words. 1959:The last invocation type is 1360:City of Industry, California 282:First segmented memory model 235:Powerful string manipulation 45:instruction sets with dense 3882:Ian Joyner's Burroughs page 3738:Gray, George (March 1999). 2867:Not counting error controls 2811:Network Definition Language 2516:object-oriented programming 2263:, the language designer of 2251:(a superset of ALGOL), and 1691:Stack speed and performance 1675:B6500, B7500 and successors 1459:; 62 years ago 1050:new name/bug fix for B6500 737:had previously implemented 675:register from MSCW at PRT+7 34:produced a family of large 4238: 3898:"Early Burroughs Machines" 3140:John Mashey (2006-08-15). 2858:There were security issues 2640:— Processor identification 2561: 2543: 2520: 2421:Top of Stack Control Word 2234:Stack structure advantages 1385: 949:second-generation computer 837:The B6500 used monolithic 827:The B6500 had paged arrays 786: 641: Return Control Word 304:B5x00 Relative Addressing 106:. In 1956, they purchased 4072:Burroughs B2500 and B4900 4010: 3765:Unisys History Newsletter 3744:Unisys History Newsletter 3722:, University of Minnesota 3720:Charles Babbage Institute 3680:– via ResearchGate. 3498:The Philadelphia Inquirer 3306:. Apr 1970. pp. 1–2. 3099:Unisys History Newsletter 3024:The Extended ALGOL Primer 2959:"Burroughs Large Systems" 2700:series of mainframes and 1510: 1498: 1364:Mission Viejo, California 1348:Orange County, California 1342:Primary lines of hardware 1185: 982: 604:Subroutine Level Flipflop 343: 338: 335: 332: 329: 326: 321: 316: 311: 308: 298:B5x00 Relative Addressing 4192:Transistorized computers 3347:. University of Auckland 3129:, Revision A, 5000-21005 2796:Burroughs Medium Systems 2771:which applications run. 2568:Programs are made up of 2401:Mark Stack Control Word 2370:Indirect Reference Word 1376:Tredyffrin, Pennsylvania 963:and changed its name to 4125:List of UNIVAC products 4041:UNIVAC 1100/2200 series 4031:Burroughs Large Systems 3987:Convergent Technologies 3919:B5500 Emulation Project 3910:, ACM Monograph Series. 3813:10.1145/1465611.1465665 3791:10.1145/1468075.1468111 3705:10.1145/1460690.1460736 3376:10.1145/1461518.1461527 3319:Hayes, John P. (1978). 2801:Burroughs Small Systems 2734:reverse Polish notation 2690:Forth - The Early Years 2665:processors running the 2621:Notable operators are: 2442:Data block descriptors 2274:in which to run tasks. 2198:EBCDIC ARRAY EA = A ; 2066:| (3, 2) The parameter 1477:Burroughs large systems 1437:John McClintock, others 1350:, and the outskirts of 942:Rice Institute Computer 932:The central concept of 660:Mark Stack Control Word 238:All code automatically 146:B5000, B5500, and B5700 108:ElectroData Corporation 18:Burroughs large systems 3914:Index of B8500 manuals 3902:University of Virginia 3775:on September 26, 2017. 3179:Burroughs (May 1967), 2656:Influence of the B5000 2540:B5000, B5500 and B5700 2506: 2328:Double Precision data 2286:and descriptor-based. 1123:semiconductor memory, 1106:semiconductor memory, 1076:semiconductor memory, 779: 251:Master Control Program 206:Partially data-driven 161:Master Control Program 3975:Burroughs Corporation 3732:Burroughs Corporation 3109:on September 26, 2017 3066:"The Burroughs B8500" 2546:B5000 instruction set 2498: 2453:Program Control Word 2210:ASCII ARRAY AA = A; 2126:| (2, 2) The integer 2118:| (2, 3) The integer 2110:| (2, 4) The integer 2030:| (4, 1) The integer 1618:DMALGOL and databases 1448:Burroughs Corporation 1233:Clearpath HMP LX 5000 1220:Clearpath HMP NX 5000 1207:Clearpath HMP NX 4000 1187:Unisys (1986–present) 1011:3x speed improvement 984:Burroughs (1961–1986) 771: 292:the software people. 59:Burroughs Corporation 3800:McKeeman, William M. 3633:. pp. 115–117. 3434:"B5500 Announcement" 3323:. pp. 148–149. 2944:improve this article 2823:Octal floating point 2558:B6500 and successors 2411:Return Control Word 2216:EBCDIC ARRAY MY_EA 2204:HEX ARRAY HA = A ; 1988:parameterized macros 1356:Pasadena, California 957:magnetic-core memory 130:processors and runs 3904:'s Computer Museum. 3822:Organick, Elliot I. 3771:(5). Archived from 3754:on October 1, 2016. 3750:(1). Archived from 3105:(5), archived from 2589:Multiple processors 2431:Segment Descriptor 2349:Uninitialized data 2278:Tagged architecture 2086:| (2, 7) The array 1955:Run invocation type 1669:B5000, B5500, B5700 1529:stack architectures 1454:First appeared 1394: 1037:new name for B5500 953:discrete transistor 862:integrated circuits 839:integrated circuits 616:Mark Stack FlipFlop 305: 167:) to that machine. 152:Robert (Bob) Barton 88:accounting machines 4217:1980s in computing 4212:1970s in computing 4207:1960s in computing 3992:Sperry Corporation 3672:10.1147/rd.82.0087 3120:Burroughs (1963), 2817:Work Flow Language 2507: 2391:Program code word 2255:, the designer of 2102:| (2, 5) The real 2094:| (2, 6) The real 2050:| (3, 4) The real 2042:| (3, 5) The real 1998:Asynchronous calls 1678:MVST (move stack). 1654:Stack architecture 961:Sperry Corporation 891:. You can help by 780: 303: 57:In the 1970s, the 4164: 4163: 4151:J. Presper Eckert 3852:on March 4, 2016. 3833:. Academic Press. 3521:"Company History" 3020: 3019: 3012: 2994: 2727:designers of the 2706:assembly language 2457: 2456: 2272:memory partitions 2007:Display registers 1974:Inline procedures 1525: 1524: 1339: 1338: 930: 929: 909: 908: 755:one-pass compiler 695: 694: 193:Assembly language 136:Microsoft Windows 16:(Redirected from 4229: 4222:48-bit computers 4146:Robert S. Barton 4077:Command AND Edit 4016: 3954: 3947: 3940: 3931: 3864: 3859:Allweiss, Jack. 3853: 3851: 3845:. Archived from 3844: 3834: 3832: 3817: 3815: 3795: 3793: 3776: 3755: 3725: 3708: 3682: 3681: 3679: 3678: 3651: 3645: 3644: 3623:Organick, Elliot 3619: 3613: 3612: 3610: 3608: 3603:on 11 March 2020 3593: 3587: 3586: 3579: 3573: 3572: 3571:on May 16, 2011. 3561: 3555: 3554: 3552: 3551: 3541: 3532: 3531: 3529: 3528: 3517: 3508: 3507: 3506: 3505: 3488: 3482: 3481: 3479: 3478: 3468: 3462: 3461: 3459: 3458: 3447: 3441: 3440: 3438: 3430: 3424: 3423: 3415: 3403: 3397: 3396: 3363: 3357: 3356: 3354: 3352: 3341: 3335: 3334: 3316: 3310: 3307: 3296: 3295: 3294: 3271: 3265: 3261: 3259: 3257: 3242: 3233: 3232: 3230: 3220: 3211: 3210: 3208: 3196: 3190: 3189: 3187: 3176: 3167: 3166: 3164: 3163: 3137: 3131: 3130: 3128: 3117: 3111: 3110: 3090: 3077: 3076: 3070: 3061: 3015: 3008: 3004: 3001: 2995: 2993: 2952: 2928: 2920: 2909: 2906: 2900: 2897: 2891: 2888: 2877: 2874: 2868: 2865: 2859: 2856: 2850: 2843:12-bit syllables 2839: 2749:Tandem Computers 2635: 2552:12-bit syllables 2528:Instruction sets 2297: 1823:to the value of 1467: 1465: 1460: 1433:Designed by 1395: 1188: 1177:MCA1, then MCA2 985: 980: 919: 918: 911: 904: 901: 883: 876: 866:thin-film memory 843:thin-film memory 821:The B6500 had a 698:Language support 688: 682: 676: 670: 661: 655: 642: 636: 627: 623: 617: 611: 605: 599: 306: 247:operating system 84:Elliott Brothers 21: 4237: 4236: 4232: 4231: 4230: 4228: 4227: 4226: 4167: 4166: 4165: 4160: 4134: 4130:UNIVAC FASTRAND 4111: 4062:Burroughs B1700 4050: 4017: 4008: 3963: 3958: 3889:- Jack Allweiss 3878: 3858: 3849: 3842: 3837: 3830: 3820: 3798: 3779: 3758: 3737: 3711: 3694: 3691: 3689:Further reading 3686: 3685: 3676: 3674: 3653: 3652: 3648: 3641: 3621: 3620: 3616: 3606: 3604: 3595: 3594: 3590: 3581: 3580: 3576: 3563: 3562: 3558: 3549: 3547: 3543: 3542: 3535: 3526: 3524: 3519: 3518: 3511: 3503: 3501: 3490: 3489: 3485: 3476: 3474: 3470: 3469: 3465: 3456: 3454: 3453:. Unisys A7-311 3449: 3448: 3444: 3436: 3432: 3431: 3427: 3422:, Digital Press 3413: 3405: 3404: 3400: 3386: 3365: 3364: 3360: 3350: 3348: 3343: 3342: 3338: 3331: 3318: 3317: 3313: 3300: 3292: 3290: 3282: 3279:Wayback Machine 3272: 3268: 3255: 3253: 3244: 3243: 3236: 3228: 3222: 3221: 3214: 3206: 3199: 3197: 3193: 3185: 3178: 3177: 3170: 3161: 3159: 3139: 3138: 3134: 3126: 3119: 3118: 3114: 3092: 3091: 3080: 3068: 3063: 3062: 3053: 3016: 3005: 2999: 2996: 2953: 2951: 2941: 2929: 2918: 2913: 2912: 2907: 2903: 2898: 2894: 2889: 2880: 2875: 2871: 2866: 2862: 2857: 2853: 2847:8-bit syllables 2840: 2836: 2831: 2792: 2725:Hewlett-Packard 2658: 2641: 2636: 2633: 2628: 2606:data type. The 2591: 2583:address couples 2570:8-bit syllables 2566: 2560: 2548: 2542: 2530: 2525: 2512: 2502:Elliot Organick 2280: 2236: 2217: 2211: 2205: 2199: 2192: 2169: 2139: 2024: 2009: 2000: 1976: 1957: 1922: 1909: 1883: 1834:; — This sets 1819:; — This sets 1799: 1717: 1693: 1656: 1620: 1582: 1554: 1463: 1461: 1458: 1393:Burroughs ALGOL 1390: 1384: 1344: 1335:e.g. Libra 750 1309:e.g. Libra 595 1186: 983: 926: 920: 916: 905: 899: 896: 889:needs expansion 874: 855: 804:12-bit syllable 791: 785: 775:Elliot Organick 747:Edsger Dijkstra 700: 691: 683: 679: 671: 664: 656: 645: 637: 630: 624: 620: 612: 608: 600: 596: 592: 580: 546: 512: 478: 444: 410: 403:Address of PRT 376: 369:Address of PRT 345: 340: 323: 318: 313: 289: 262:multiprocessing 260:(master/slave) 245:Support for an 187:instruction set 173: 148: 80: 28: 23: 22: 15: 12: 11: 5: 4235: 4233: 4225: 4224: 4219: 4214: 4209: 4204: 4199: 4194: 4189: 4187:Stack machines 4184: 4179: 4169: 4168: 4162: 4161: 4159: 4158: 4153: 4148: 4142: 4140: 4136: 4135: 4133: 4132: 4127: 4121: 4119: 4113: 4112: 4110: 4109: 4104: 4099: 4094: 4089: 4084: 4079: 4074: 4069: 4064: 4058: 4056: 4052: 4051: 4049: 4048: 4043: 4038: 4033: 4027: 4025: 4019: 4018: 4011: 4009: 4007: 4006: 4005: 4004: 4002:Remington Rand 3999: 3989: 3984: 3983: 3982: 3971: 3969: 3965: 3964: 3959: 3957: 3956: 3949: 3942: 3934: 3928: 3927: 3922: 3916: 3911: 3905: 3895: 3890: 3884: 3877: 3876:External links 3874: 3873: 3872: 3865: 3856: 3835: 3818: 3796: 3777: 3756: 3735: 3709: 3690: 3687: 3684: 3683: 3646: 3639: 3614: 3588: 3574: 3556: 3533: 3509: 3483: 3463: 3442: 3425: 3398: 3384: 3358: 3336: 3329: 3311: 3309: 3308: 3266: 3234: 3212: 3191: 3168: 3132: 3112: 3078: 3050: 3049: 3048: 3047: 3041: 3033: 3027: 3018: 3017: 2932: 2930: 2923: 2917: 2914: 2911: 2910: 2901: 2892: 2878: 2869: 2860: 2851: 2833: 2832: 2830: 2827: 2826: 2825: 2820: 2814: 2808: 2803: 2798: 2791: 2788: 2780:Intel iAPX 432 2738:HP calculators 2702:supercomputers 2657: 2654: 2650:deadly embrace 2590: 2587: 2562:Main article: 2559: 2556: 2544:Main article: 2541: 2538: 2529: 2526: 2521:Main article: 2511: 2508: 2455: 2454: 2451: 2448: 2444: 2443: 2440: 2437: 2433: 2432: 2429: 2426: 2423: 2422: 2419: 2416: 2413: 2412: 2409: 2406: 2403: 2402: 2399: 2396: 2393: 2392: 2389: 2386: 2382: 2381: 2378: 2375: 2372: 2371: 2368: 2365: 2361: 2360: 2357: 2354: 2351: 2350: 2347: 2345: 2341: 2340: 2337: 2334: 2330: 2329: 2326: 2323: 2319: 2318: 2315: 2312: 2308: 2307: 2304: 2301: 2279: 2276: 2235: 2232: 2215: 2209: 2203: 2197: 2190: 2168: 2165: 2070:from value of 2025: 2022: 2008: 2005: 1999: 1996: 1975: 1972: 1956: 1953: 1943:instruction. 1921: 1918: 1892:; ..... 1721: 1716: 1713: 1692: 1689: 1680: 1679: 1676: 1673: 1670: 1655: 1652: 1619: 1616: 1581: 1578: 1553: 1552:ESPOL and NEWP 1550: 1523: 1522: 1508: 1507: 1503: 1502: 1496: 1495: 1491: 1490: 1485: 1479: 1478: 1475: 1469: 1468: 1455: 1451: 1450: 1445: 1439: 1438: 1435: 1429: 1428: 1423: 1419: 1418: 1404:Multi-paradigm 1401: 1386:Main article: 1383: 1380: 1343: 1340: 1337: 1336: 1333: 1330: 1324: 1323: 1320: 1317: 1311: 1310: 1307: 1304: 1298: 1297: 1294: 1291: 1285: 1284: 1281: 1278: 1272: 1271: 1268: 1265: 1259: 1258: 1255: 1252: 1246: 1245: 1238: 1235: 1229: 1228: 1225: 1222: 1216: 1215: 1212: 1209: 1203: 1202: 1199: 1196: 1190: 1189: 1183: 1182: 1171: 1168: 1162: 1161: 1158: 1155: 1149: 1148: 1144:architecture, 1138: 1135: 1129: 1128: 1121: 1118: 1112: 1111: 1104: 1101: 1095: 1094: 1091: 1088: 1082: 1081: 1074: 1071: 1065: 1064: 1061: 1058: 1052: 1051: 1048: 1045: 1039: 1038: 1035: 1032: 1026: 1025: 1022: 1019: 1013: 1012: 1009: 1006: 1000: 999: 996: 993: 987: 986: 938:Ferranti Atlas 934:virtual memory 928: 927: 923: 921: 914: 907: 906: 886: 884: 873: 870: 864:with magnetic 854: 851: 847: 846: 841:with magnetic 835: 830:The B6500 had 828: 825: 819: 815:The B6500 had 813: 807: 800:8-bit syllable 784: 781: 720:C. A. R. Hoare 699: 696: 693: 692: 690: 689: 677: 662: 643: 628: 618: 606: 593: 586: 585: 582: 577: 574: 571: 568: 565: 562: 559: 556: 552: 551: 548: 543: 540: 537: 534: 531: 528: 525: 522: 518: 517: 514: 509: 506: 503: 500: 497: 494: 491: 488: 484: 483: 480: 475: 472: 469: 466: 463: 460: 457: 454: 450: 449: 446: 441: 438: 435: 432: 429: 426: 423: 420: 416: 415: 412: 407: 404: 401: 398: 395: 392: 389: 386: 382: 381: 378: 373: 370: 367: 364: 361: 358: 355: 352: 348: 347: 342: 337: 334: 331: 328: 325: 320: 315: 310: 288: 285: 284: 283: 280: 270: 267: 264: 254: 243: 236: 233: 227: 224: 218: 215: 204: 189: 183: 177: 172: 169: 147: 144: 79: 76: 68:Medium Systems 26: 24: 14: 13: 10: 9: 6: 4: 3: 2: 4234: 4223: 4220: 4218: 4215: 4213: 4210: 4208: 4205: 4203: 4200: 4198: 4195: 4193: 4190: 4188: 4185: 4183: 4180: 4178: 4175: 4174: 4172: 4157: 4156:Peter Altabef 4154: 4152: 4149: 4147: 4144: 4143: 4141: 4137: 4131: 4128: 4126: 4123: 4122: 4120: 4118: 4114: 4108: 4105: 4103: 4100: 4098: 4095: 4093: 4090: 4088: 4085: 4083: 4080: 4078: 4075: 4073: 4070: 4068: 4067:Burroughs B20 4065: 4063: 4060: 4059: 4057: 4053: 4047: 4044: 4042: 4039: 4037: 4034: 4032: 4029: 4028: 4026: 4024: 4020: 4015: 4003: 4000: 3998: 3995: 3994: 3993: 3990: 3988: 3985: 3981: 3978: 3977: 3976: 3973: 3972: 3970: 3966: 3962: 3955: 3950: 3948: 3943: 3941: 3936: 3935: 3932: 3926: 3923: 3920: 3917: 3915: 3912: 3909: 3906: 3903: 3899: 3896: 3894: 3891: 3888: 3885: 3883: 3880: 3879: 3875: 3870: 3867:Martin, Ian. 3866: 3862: 3857: 3855: 3848: 3841: 3836: 3829: 3828: 3823: 3819: 3814: 3809: 3805: 3801: 3797: 3792: 3787: 3783: 3778: 3774: 3770: 3766: 3762: 3757: 3753: 3749: 3745: 3741: 3736: 3733: 3729: 3723: 3721: 3716: 3710: 3706: 3702: 3698: 3693: 3692: 3688: 3673: 3669: 3666:(2): 87–101. 3665: 3661: 3657: 3650: 3647: 3642: 3640:0-12-528250-8 3636: 3632: 3628: 3624: 3618: 3615: 3602: 3598: 3592: 3589: 3584: 3578: 3575: 3570: 3566: 3560: 3557: 3546: 3540: 3538: 3534: 3523:. 9 July 2021 3522: 3516: 3514: 3510: 3500: 3499: 3494: 3487: 3484: 3473: 3467: 3464: 3452: 3446: 3443: 3435: 3429: 3426: 3421: 3420: 3412: 3408: 3407:Henry M. Levy 3402: 3399: 3395: 3391: 3387: 3385:9781450378796 3381: 3377: 3373: 3369: 3362: 3359: 3346: 3340: 3337: 3332: 3330:0-07-027363-4 3326: 3322: 3315: 3312: 3305: 3304: 3298: 3297: 3288: 3287: 3280: 3276: 3270: 3267: 3264: 3251: 3250:ed-thelen.org 3247: 3241: 3239: 3235: 3227: 3226: 3219: 3217: 3213: 3205: 3204: 3195: 3192: 3184: 3183: 3175: 3173: 3169: 3158: 3155: 3151: 3147: 3143: 3136: 3133: 3125: 3124: 3116: 3113: 3108: 3104: 3100: 3096: 3089: 3087: 3085: 3083: 3079: 3074: 3067: 3060: 3058: 3056: 3052: 3046: 3045:bitsavers.org 3042: 3040: 3037: 3034: 3031: 3028: 3025: 3022: 3021: 3014: 3011: 3003: 3000:November 2009 2992: 2989: 2985: 2982: 2978: 2975: 2971: 2968: 2964: 2961: – 2960: 2956: 2955:Find sources: 2949: 2945: 2939: 2938: 2933:This article 2931: 2927: 2922: 2921: 2915: 2905: 2902: 2896: 2893: 2887: 2885: 2883: 2879: 2873: 2870: 2864: 2861: 2855: 2852: 2848: 2844: 2838: 2835: 2828: 2824: 2821: 2818: 2815: 2812: 2809: 2807: 2804: 2802: 2799: 2797: 2794: 2793: 2789: 2787: 2785: 2781: 2777: 2772: 2768: 2766: 2762: 2757: 2755: 2750: 2745: 2743: 2739: 2735: 2730: 2726: 2721: 2719: 2715: 2711: 2707: 2703: 2699: 2694: 2692: 2691: 2686: 2682: 2677: 2674: 2672: 2668: 2664: 2655: 2653: 2651: 2646: 2644: 2639: 2634:x:=RDLK(x,y); 2631: 2626: 2622: 2619: 2617: 2613: 2609: 2605: 2601: 2597: 2588: 2586: 2584: 2579: 2575: 2571: 2565: 2557: 2555: 2553: 2547: 2539: 2537: 2535: 2527: 2524: 2519: 2517: 2509: 2505: 2503: 2497: 2493: 2490: 2486: 2483: 2481: 2477: 2471: 2467: 2464: 2462: 2452: 2449: 2446: 2445: 2441: 2438: 2435: 2434: 2430: 2427: 2425: 2424: 2420: 2417: 2415: 2414: 2410: 2407: 2405: 2404: 2400: 2397: 2395: 2394: 2390: 2387: 2384: 2383: 2379: 2376: 2374: 2373: 2369: 2366: 2363: 2362: 2358: 2355: 2353: 2352: 2348: 2346: 2343: 2342: 2338: 2335: 2332: 2331: 2327: 2324: 2321: 2320: 2316: 2313: 2310: 2309: 2305: 2302: 2299: 2298: 2295: 2291: 2287: 2285: 2277: 2275: 2273: 2268: 2266: 2262: 2261:John McCarthy 2258: 2254: 2250: 2244: 2240: 2233: 2231: 2228: 2225: 2221: 2214: 2208: 2202: 2196: 2189: 2185: 2181: 2177: 2173: 2167:Array storage 2166: 2164: 2160: 2157: 2151: 2147: 2143: 2137: 2133: 2129: 2125: 2121: 2117: 2113: 2109: 2105: 2101: 2097: 2093: 2089: 2085: 2081: 2077: 2073: 2069: 2065: 2061: 2057: 2053: 2049: 2045: 2041: 2037: 2033: 2029: 2026:| 0 | 2021: 2017: 2013: 2006: 2004: 1997: 1995: 1993: 1989: 1985: 1981: 1973: 1971: 1969: 1964: 1962: 1954: 1952: 1949: 1944: 1942: 1937: 1932: 1930: 1925: 1919: 1917: 1913: 1907: 1903: 1899: 1895: 1891: 1887: 1881: 1878: 1874: 1871: 1868: 1864: 1861: 1857: 1853: 1849: 1845: 1841: 1837: 1833: 1829: 1826: 1822: 1818: 1814: 1810: 1806: 1802: 1797: 1793: 1790: 1786: 1782: 1779: 1775: 1771: 1768: 1764: 1761: 1757: 1754: 1750: 1746: 1743: 1739: 1735: 1731: 1728: 1724: 1720: 1714: 1712: 1708: 1704: 1700: 1698: 1690: 1688: 1684: 1677: 1674: 1671: 1668: 1667: 1666: 1664: 1660: 1653: 1651: 1647: 1645: 1640: 1636: 1633: 1628: 1624: 1617: 1615: 1611: 1607: 1604: 1598: 1594: 1590: 1588: 1579: 1577: 1573: 1569: 1567: 1563: 1559: 1551: 1549: 1545: 1542: 1536: 1532: 1530: 1521: 1517: 1513: 1509: 1504: 1501: 1497: 1494:Influenced by 1492: 1489: 1488:Burroughs MCP 1486: 1484: 1480: 1476: 1474: 1470: 1456: 1452: 1449: 1446: 1444: 1440: 1436: 1434: 1430: 1427: 1424: 1420: 1417: 1413: 1409: 1405: 1402: 1400: 1396: 1389: 1381: 1379: 1377: 1373: 1369: 1365: 1361: 1358:but moved to 1357: 1353: 1349: 1341: 1334: 1331: 1329: 1326: 1325: 1321: 1318: 1316: 1313: 1312: 1308: 1305: 1303: 1300: 1299: 1295: 1292: 1290: 1287: 1286: 1282: 1279: 1277: 1274: 1273: 1269: 1266: 1264: 1261: 1260: 1256: 1253: 1251: 1248: 1247: 1243: 1239: 1236: 1234: 1231: 1230: 1226: 1223: 1221: 1218: 1217: 1213: 1210: 1208: 1205: 1204: 1200: 1197: 1195: 1192: 1191: 1184: 1180: 1176: 1172: 1169: 1167: 1164: 1163: 1159: 1156: 1154: 1151: 1150: 1147: 1143: 1139: 1136: 1134: 1131: 1130: 1126: 1122: 1119: 1117: 1114: 1113: 1109: 1105: 1102: 1100: 1097: 1096: 1092: 1089: 1087: 1084: 1083: 1080:architecture 1079: 1075: 1072: 1070: 1067: 1066: 1062: 1059: 1057: 1054: 1053: 1049: 1046: 1044: 1041: 1040: 1036: 1033: 1031: 1028: 1027: 1023: 1020: 1018: 1015: 1014: 1010: 1007: 1005: 1002: 1001: 997: 994: 992: 989: 988: 981: 978: 976: 973: 972: 966: 962: 958: 954: 950: 945: 943: 939: 935: 922: 913: 912: 903: 894: 890: 887:This section 885: 882: 878: 877: 871: 869: 867: 863: 858: 852: 850: 844: 840: 836: 833: 829: 826: 824: 823:Saguaro stack 820: 818: 814: 812: 808: 805: 801: 797: 796: 795: 790: 782: 778: 776: 770: 766: 762: 760: 759:punched cards 756: 752: 748: 743: 740: 736: 731: 729: 725: 721: 717: 716:Elliott ALGOL 713: 709: 705: 697: 686: 681: 678: 674: 669: 667: 663: 659: 654: 652: 650: 648: 644: 640: 635: 633: 629: 622: 619: 615: 610: 607: 603: 598: 595: 591: 587: 583: 578: 575: 572: 569: 566: 563: 560: 557: 554: 553: 549: 544: 541: 538: 535: 532: 529: 526: 523: 520: 519: 515: 510: 507: 504: 501: 498: 495: 492: 489: 486: 485: 481: 476: 473: 470: 467: 464: 461: 458: 455: 452: 451: 447: 442: 439: 436: 433: 430: 427: 424: 421: 418: 417: 413: 408: 405: 402: 399: 396: 393: 390: 387: 384: 383: 379: 374: 371: 368: 365: 362: 359: 356: 353: 350: 349: 307: 301: 299: 293: 287:System design 286: 281: 278: 275: 271: 268: 265: 263: 259: 255: 252: 248: 244: 241: 237: 234: 232: 228: 225: 222: 221:Stack machine 219: 216: 214:-based design 213: 209: 205: 202: 198: 194: 190: 188: 184: 182: 178: 175: 174: 170: 168: 166: 162: 157: 153: 145: 143: 141: 137: 133: 129: 125: 121: 117: 111: 109: 105: 101: 97: 93: 89: 85: 77: 75: 73: 72:Small Systems 69: 65: 60: 55: 52: 48: 44: 43:stack machine 40: 37: 33: 19: 4097:MCP Compiler 4030: 3847:the original 3826: 3803: 3781: 3773:the original 3768: 3764: 3752:the original 3747: 3743: 3718: 3696: 3675:. Retrieved 3663: 3659: 3649: 3626: 3617: 3605:. Retrieved 3601:the original 3591: 3577: 3569:the original 3559: 3548:. Retrieved 3525:. Retrieved 3502:, retrieved 3496: 3486: 3475:. Retrieved 3466: 3455:. Retrieved 3445: 3428: 3418: 3401: 3367: 3361: 3349:. Retrieved 3339: 3320: 3314: 3302: 3291:, retrieved 3285: 3275:Ghostarchive 3273:Archived at 3269: 3256:February 21, 3254:. Retrieved 3249: 3224: 3202: 3194: 3181: 3160:. Retrieved 3135: 3122: 3115: 3107:the original 3102: 3098: 3072: 3035: 3029: 3023: 3006: 2997: 2987: 2980: 2973: 2966: 2954: 2942:Please help 2937:verification 2934: 2904: 2895: 2872: 2863: 2854: 2837: 2783: 2773: 2769: 2758: 2746: 2722: 2695: 2689: 2678: 2675: 2659: 2647: 2642: 2637: 2629: 2624: 2623: 2620: 2615: 2611: 2607: 2603: 2599: 2595: 2592: 2567: 2549: 2531: 2513: 2500: 2491: 2487: 2484: 2482:statements. 2479: 2475: 2472: 2468: 2465: 2461:Hamming code 2458: 2306:Description 2292: 2288: 2281: 2269: 2245: 2241: 2237: 2229: 2226: 2222: 2218: 2212: 2206: 2200: 2193: 2186: 2182: 2178: 2174: 2170: 2161: 2155: 2152: 2148: 2144: 2140: 2135: 2131: 2127: 2123: 2119: 2115: 2111: 2107: 2103: 2099: 2095: 2091: 2087: 2083: 2079: 2075: 2071: 2067: 2063: 2059: 2055: 2051: 2047: 2043: 2039: 2035: 2031: 2027: 2018: 2014: 2010: 2001: 1979: 1977: 1965: 1960: 1958: 1947: 1945: 1940: 1935: 1933: 1928: 1926: 1923: 1914: 1910: 1905: 1901: 1897: 1893: 1889: 1885: 1879: 1876: 1872: 1869: 1866: 1862: 1859: 1855: 1851: 1847: 1843: 1839: 1835: 1831: 1827: 1824: 1820: 1816: 1812: 1808: 1804: 1800: 1795: 1791: 1788: 1784: 1780: 1777: 1773: 1769: 1766: 1762: 1759: 1755: 1752: 1748: 1744: 1741: 1737: 1733: 1729: 1726: 1722: 1718: 1709: 1705: 1701: 1694: 1685: 1681: 1663:Multitasking 1661: 1657: 1648: 1641: 1637: 1629: 1625: 1621: 1612: 1608: 1599: 1595: 1591: 1583: 1574: 1570: 1565: 1555: 1546: 1537: 1533: 1526: 1352:Philadelphia 1345: 1327: 1314: 1301: 1288: 1275: 1262: 1249: 1244:processors) 1232: 1219: 1206: 1193: 1165: 1152: 1145: 1132: 1115: 1098: 1085: 1068: 1055: 1042: 1029: 1016: 1003: 990: 968: 946: 931: 897: 893:adding to it 888: 859: 856: 848: 831: 792: 773: 763: 744: 735:Donald Knuth 732: 728:Turing Award 701: 684: 680: 672: 657: 638: 621: 613: 609: 601: 597: 589: 294: 290: 256:Support for 164: 149: 112: 90:such as the 81: 56: 31: 29: 4107:Unisys Icon 3597:"Libra 750" 3583:"Libra 595" 3198:Taken from 2845:for B5000, 2681:Chuck Moore 2671:native mode 2578:polymorphic 1811:; 1372:Lake Forest 1179:gate arrays 724:Elliott 503 336:Index Sign 185:Simplified 156:John Mashey 66:-optimized 4171:Categories 4023:Mainframes 3677:2021-09-10 3550:2021-08-28 3527:2021-08-28 3504:2011-04-16 3477:2023-03-30 3457:2023-03-30 3293:2019-03-04 3162:2007-12-15 3073:Datamation 2970:newspapers 2916:References 2663:Intel Xeon 2439:Descriptor 1920:Procedures 1842:, but not 1697:System/360 1603:middleware 1506:Influenced 1416:structured 1412:imperative 1408:procedural 955:logic and 787:See also: 258:asymmetric 212:descriptor 92:Sensimatic 78:Background 39:mainframes 3585:. Unisys. 3188:, 1021326 3150:comp.arch 3146:Newsgroup 2849:for B6500 2765:Smalltalk 2718:VLIW CPUs 2574:operators 2534:syllables 2303:Word kind 2284:tag-based 2191:ARRAY A 1830: := 1815: := 1803: := 1776:); 1760:procedure 1443:Developer 1399:Paradigms 1328:Libra 700 1315:Libra 600 1302:Libra 500 1289:Libra 400 1276:Libra 300 1263:Libra 200 1250:Libra 100 900:June 2008 706:and then 333:Contents 240:reentrant 74:(B1000). 47:syllables 4092:LINC 4GL 4087:HOLMES 2 4055:Products 3824:(1973). 3802:(1967). 3625:(1973). 3277:and the 2790:See also 2761:Alan Kay 2710:ALGOL 68 2612:READLOCK 1990:such as 1941:CONTINUE 1888:; 1541:#defines 1500:ALGOL 60 1473:Platform 940:and the 739:ALGOL 58 712:ALGOL-60 581:A 41-47 547:A 41-47 513:A 41-47 479:A 40-47 445:A 40-47 411:A 39-47 377:A 38-47 274:Ferranti 197:ALGOL 60 171:Features 51:ALGOL 60 4046:OS 2200 3968:History 3699:. ACM. 3394:1186864 3263:Alt URL 3154:Usenet: 3148:: 3075:: 49–50 2984:scholar 2754:Itanium 2729:HP 3000 2480:PROCESS 2253:Iverson 1948:process 1877:integer 1727:integer 1462: ( 1194:Micro A 1166:A12/A15 872:History 704:FORTRAN 4197:Unisys 4139:People 4117:UNIVAC 4082:ES7000 3961:Unisys 3637: 3607:16 May 3392: 3382: 3351:18 May 3327: 3156: 2986: 2979: 2972: 2965: 2957: 2841:E.g., 2716:-like 2698:Elbrus 2325:Double 2249:Simula 1980:INLINE 1929:normal 1422:Family 1368:Irvine 1153:A9/A10 965:Unisys 951:using 722:on an 590:Notes: 570:(R+7) 468:(R+7) 346:Index 249:(MCP, 208:tagged 199:named 116:Unisys 104:Univac 41:using 36:48-bit 3850:(PDF) 3843:(PDF) 3831:(PDF) 3728:AFIPS 3437:(PDF) 3414:(PDF) 3390:S2CID 3229:(PDF) 3207:(PDF) 3186:(PDF) 3127:(PDF) 3069:(PDF) 2991:JSTOR 2977:books 2829:Notes 2819:(WFL) 2813:(NDL) 2806:CANDE 2784:would 2742:HP-35 2685:Forth 2608:EVENT 2604:EVENT 2504:1973. 2418:TOSCW 1873:begin 1865:> 1856:might 1785:begin 1778:value 1758:; 1753:array 1751:; 1740:; 1723:begin 1644:DMSII 1632:DMSII 1558:ESPOL 1512:ESPOL 1426:ALGOL 1388:ALGOL 1382:ALGOL 1319:2006? 1306:2005? 1254:2002? 1224:1996? 1211:1996? 1137:1982? 1133:B7900 1116:B5900 1103:1979? 1099:B6900 1090:1977? 1086:B7800 1073:1977? 1069:B6800 1056:B7700 1043:B6700 1030:B5700 1017:B6500 1004:B5500 991:B5000 925:line. 853:B8500 777:1973. 708:COBOL 579:T 3-9 545:T 3-9 511:T 3-9 477:T 2-9 443:T 2-9 409:T 1-9 380:1023 375:T 0-9 341:Bits 339:Index 330:Base 327:MSFF 309:SALF 277:Atlas 231:COBOL 201:ESPOL 140:Linux 64:COBOL 3730:and 3635:ISBN 3609:2018 3380:ISBN 3353:2020 3325:ISBN 3258:2019 2963:news 2723:The 2714:EPIC 2643:IDLE 2638:WHOI 2630:RDLK 2625:HEYU 2616:RDLK 2600:RDLK 2596:RDLK 2478:and 2476:CALL 2398:MSCW 2388:Code 2377:SIRW 2314:Data 2265:LISP 2136:MSCW 2080:MSCW 2036:MSCW 1946:The 1936:call 1934:The 1927:The 1870:then 1789:real 1767:real 1742:real 1562:NEWP 1520:NEWP 1464:1962 1457:1962 1370:and 1332:2010 1293:200? 1280:200? 1267:200? 1242:Xeon 1237:1998 1198:1989 1170:1985 1157:1984 1142:NUMA 1125:NUMA 1120:1981 1108:NUMA 1078:NUMA 1060:1972 1047:1971 1034:1971 1021:1969 1008:1964 995:1961 975:ASIC 971:CMOS 969:MCP 658:MSCW 626:off. 614:MSFF 602:SALF 584:127 550:127 533:OFF 516:127 496:OFF 482:255 459:OFF 448:255 431:OFF 425:OFF 414:511 388:OFF 351:OFF 324:A40 319:A39 314:A38 210:and 138:and 128:Xeon 124:CMOS 98:and 30:The 4036:MCP 3808:doi 3786:doi 3701:doi 3668:doi 3631:ACM 3372:doi 2946:by 2776:x86 2667:x86 2652:'. 2450:PCW 2408:RCW 2367:IRW 2356:SCW 2336:SIW 2300:Tag 2257:APL 2156:not 2132:RCW 2076:RCW 1968:Ada 1961:run 1906:end 1904:); 1890:end 1886:end 1854:it 1850:in 1838:to 1587:NDL 1516:MCP 1322:?? 1296:?? 1283:?? 1270:?? 1257:?? 1175:ECL 895:. 811:tag 639:RCW 567:ON 564:ON 561:ON 558:ON 555:ON 530:ON 527:ON 524:ON 521:ON 493:ON 490:ON 487:ON 465:ON 456:ON 453:ON 422:ON 419:ON 385:ON 344:Max 191:No 165:MCP 132:MCP 120:MCP 100:NCR 96:IBM 4173:: 3900:, 3767:. 3763:. 3746:. 3742:. 3717:. 3662:. 3658:. 3629:. 3536:^ 3512:^ 3495:, 3416:, 3409:, 3388:, 3378:, 3281:: 3248:. 3237:^ 3215:^ 3171:^ 3152:. 3144:. 3101:, 3097:, 3081:^ 3071:, 3054:^ 2881:^ 2782:, 2767:. 2720:. 2428:SD 2068:p1 2064:p1 2056:p2 2052:r1 2048:r1 2044:r2 2040:r2 1908:. 1900:, 1867:10 1863:r2 1860:if 1852:p1 1840:r2 1836:p1 1832:r2 1828:p1 1825:r2 1817:r2 1813:p2 1807:* 1805:p1 1801:r2 1796:r2 1794:, 1792:r1 1781:p1 1774:p2 1772:, 1770:p1 1747:, 1736:, 1732:, 1646:. 1518:, 1514:, 1483:OS 1414:, 1410:, 1406:: 1227:? 1214:? 665:^ 646:^ 631:^ 576:- 542:- 536:F 508:+ 502:C 499:- 474:+ 462:- 440:+ 434:F 428:- 406:+ 400:R 397:- 394:- 391:- 372:+ 366:R 363:- 360:- 357:- 354:- 322:T2 317:T1 312:T0 300:. 134:, 3953:e 3946:t 3939:v 3863:. 3816:. 3810:: 3794:. 3788:: 3769:3 3748:3 3734:. 3724:. 3707:. 3703:: 3670:: 3664:8 3643:. 3611:. 3553:. 3530:. 3480:. 3460:. 3374:: 3355:. 3333:. 3260:. 3165:. 3103:3 3013:) 3007:( 3002:) 2998:( 2988:· 2981:· 2974:· 2967:· 2940:. 2447:7 2436:5 2385:3 2364:1 2344:6 2333:4 2322:2 2311:0 2128:i 2124:i 2120:j 2116:j 2112:k 2108:k 2104:f 2100:f 2096:g 2092:g 2088:a 2084:a 2072:f 2060:g 2032:n 2028:n 1992:C 1902:g 1898:f 1896:( 1894:p 1882:; 1880:n 1848:f 1844:f 1821:g 1809:5 1798:; 1765:( 1763:p 1756:a 1749:g 1745:f 1738:k 1734:j 1730:i 1466:) 902:) 898:( 845:. 806:. 685:C 673:F 279:. 253:) 163:( 20:)

Text is available under the Creative Commons Attribution-ShareAlike License. Additional terms may apply.