Misplaced Pages

#651348

59-512: In the 1970s, the Burroughs Corporation 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. "Burroughs Large Systems" referred to all of these large-system product lines together, in contrast to

118-673: A middleware 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 Edit) which was developed as the online program development environment. The University of Otago in New Zealand developed

177-453: A block is specifically marked to allow those instructions. Such marking of blocks provide a multi-level protection mechanism. 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 to do this depending on

236-697: A completed system. The central concept of virtual memory appeared in the designs of the Ferranti Atlas and the Rice Institute Computer , 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

295-424: 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. 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

354-429: 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. Around 1988 an implementation of TCP/IP was developed principally for a U.S. government customer utilizing

413-411: A newer, mostly untried language was adopted, ALGOL-60 . The ALGOL dialect chosen for the B5000 was Elliott ALGOL , first designed and implemented by C. A. R. Hoare on an Elliott 503 . This was a practical extension of ALGOL with I/O instructions (which ALGOL had ignored) and powerful string processing instructions. Hoare's famous Turing Award lecture was on this subject. Thus the B5000 was based on

472-560: A preprocessor. The EVENT data type facilitates coordination between processes, and ON FAULT blocks enable handling program faults. 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 more specific extensions for specific kinds of system software. Originally,

531-412: 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 IP1, IP2 or MVST, and there is only one place in the operating system where this is done. So a process switch proceeds something like this – a process requests a resource that

590-616: 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. 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

649-428: A program, not the dynamic call nesting. The visibility rules of ALGOL, a language designed for single pass compilers, mean that only variables declared 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

SECTION 10

#1732779600652

708-619: 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

767-445: A very powerful language. Donald Knuth had previously implemented ALGOL 58 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 as a systems programming language. The Burroughs ALGOL compiler

826-471: 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. Stack performance was considered to be slow compared to register-based architectures, for example, such an architecture had been considered and rejected for the System/360 . One way to increase system speed

885-437: 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 implemented to solve the deadlock situation when multiple processes accessed and updated the same structures. Roy Guck of Burroughs was one of the main developers of DMSII . In later years, with compiler code size being less of

944-406: 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 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

1003-401: 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 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. In fact, the A Series line of B5000 successors included

1062-470: 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

1121-472: 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 years over many processor upgrades. Such speed up is limited on register-based machines. Another point for speed as promoted by the RISC designers was that processor speed is considerably faster if everything

1180-429: 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. Thus the designers of the current successors to the B5000 systems can optimize in whatever

1239-483: Is used to provide tailored access routines for DMSII 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 database-specific if/then/else code at run-time. In the 1970s, this "tailoring"

SECTION 20

#1732779600652

1298-480: The COBOL -optimized Medium Systems (B2000, B3000, and B4000) or the flexible-architecture Small Systems (B1000). Founded in the 1880s, Burroughs was the oldest continuously operating company in computing ( Elliott Brothers 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 accounting machines such as

1357-518: The Sensimatic . It had nothing to compete with its traditional rivals IBM and NCR , who had started to produce larger-scale computers, or with recently founded Univac . In 1956, they purchased ElectroData Corporation and rebranded its design as the B205. Burroughs' first internally developed machine, the B5000, was designed in 1961 and Burroughs sought to address its late entry in the market with

1416-684: The Atlas and the Rice machine; they are also very different from each other. The first of the Burroughs large systems was the B5000. Designed in 1961, it was a second-generation computer using discrete transistor logic and magnetic-core memory , 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

1475-496: The B5000 MCP operating system was written in an extension of extended ALGOL called ESPOL (Executive Systems Programming Oriented Language). This was replaced in the mid-to-late 70s by a language called NEWP . 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 " No Executive Washroom Privileges ." Another story

1534-637: 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 NDL (Network Definition Language) compiler generated the DCP code and NDF (network definition file). Ultimately, a further update resulted in

1593-569: The B6700. The third and largest line, the B8500, had no commercial success. In addition to a proprietary CMOS processor design, Unisys also uses Intel Xeon processors and runs MCP , Microsoft Windows and Linux 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. The first member of

1652-489: The Bxx00 models were replaced by the A Series models, the differences were retained but no longer readily identifiable by model number. The Burroughs large systems implement ALGOL-derived stack architectures . The B5000 was the first stack-based system. 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

1711-571: 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 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

1770-402: 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 identified to handle traffic from the particular source device and return any response to the DCP for delivery to the destination device. From

1829-823: The East Coast operations, based in Tredyffrin, Pennsylvania , 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

Burroughs Large Systems - Misplaced Pages Continue

1888-718: 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. 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. Hardware and software design, development, and manufacturing were split between two primary locations, in Orange County, California , and

1947-565: The OSI standard defined applications were implemented including X.400 mail hosting and X.500 directory services. 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 descriptions to generate DMALGOL code tailored for

2006-775: The T field of an Operand Call or Descriptor Call syllable is relative to the Program Reference Table (PRT). For subroutines, the type of addressing is dependent on the high three bits of T and on the Mark Stack FlipFlop (MSFF), as shown in B5x00 Relative Addressing . The B5000 was designed to exclusively support high-level languages. This was at a time when such languages were just coming to prominence with FORTRAN and then COBOL . FORTRAN and COBOL were considered weaker languages by some, when it comes to modern software techniques, so

2065-468: 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. 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

2124-479: The data as global within the module. Interfaces allow a module to import and export functions and data. Super-modules allow modules to be grouped. 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 remote terminals. The DCP and

2183-577: The delivery of application data to online production environments and the return of responses to remote users/devices/systems. 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 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

2242-505: 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

2301-456: 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 Among other customers of the B6700 and B7700 were all five New Zealand universities in 1971. The B8500 line derives from the D825, a military computer that was inspired by the B5000. The B8500

2360-409: The first series, the B5000, was designed beginning in 1961 by a team under the leadership of Robert (Bob) Barton . It had an unusual architecture. It has been listed by the computing scientist John Mashey 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

2419-502: 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. Here is an example of how programs map to the stack structure 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

Burroughs Large Systems - Misplaced Pages Continue

2478-593: The generation method frequently nested procedure within procedure. Procedures can be invoked in four ways – normal, call, process, and run. Burroughs Corporation Too Many Requests If you report this error to the Wikimedia System Administrators, please include the details below. Request from 172.68.168.226 via cp1108 cp1108, Varnish XID 217833868 Upstream caches: cp1108 int Error: 429, Too Many Requests at Thu, 28 Nov 2024 07:40:00 GMT Elliott 503 The Elliott 503

2537-462: 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 Sperry Corporation and changed its name to Unisys , the company continued to develop new machines based on the MCP CMOS ASIC . These machines were

2596-481: 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. 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

2655-469: 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 the software people. 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,

2714-704: The network via freestanding devices called CP2000s. The 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. On input, messages were passed from

2773-447: The outer variables which become inaccessible. 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 for some systems that generated Algol source as output (tailored to solve some special problem) if

2832-540: The outskirts of Philadelphia . The initial Large Systems Plant, which developed the B5000 and B5500, was located in Pasadena, California but moved to City of Industry, California , where it developed the B6500. The Orange County location, which was based in a plant in Mission Viejo, California but at times included facilities in nearby Irvine and Lake Forest , was responsible for the smaller B6x00 line, while

2891-413: The powerful string operators which were included for the development of fast compilers. 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 #defines found in C, but is fully integrated into the language rather than being

2950-400: The source code from the punched cards , and they had the fastest card readers in the industry. 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. The B6500 (delivery in 1969) and B7500 were

3009-475: 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

SECTION 50

#1732779600652

3068-488: The stack. The B5000 was designed as a stack machine – all program data except for arrays (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. Multitasking is also very efficient on the B5000 and B6500 lines. There are specific instruction to perform process switches: Each stack and associated Program Reference Table (PRT) represents

3127-522: 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 inspired the B6500 (and subsequent B6700 and B7700). Computers using that architecture were still in production as the Unisys ClearPath Libra servers which run an evolved but compatible version of the MCP operating system first introduced with

3186-620: 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. 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. DMALGOL

3245-455: Was a transistorized computer introduced by Elliott Brothers in 1963. It was software-compatible with the earlier Elliott 803 but was about 70 times faster and a more powerful machine. About 32 units were sold. The basic configuration had 8192 words of 39 bits each for main memory, and operated at a system clock speed of 6.7 megahertz . It weighed more than 4,050 pounds (2.0 short tons; 1.8 t). This computer hardware article

3304-411: Was designed in the 1960s as an attempt to merge the B5500 and the D825 designs. The system used monolithic integrated circuits with magnetic thin-film memory . 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

3363-552: Was succeeded by the B5500, which used disks rather than drum storage, and the B5700, which allowed 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 Master Control Program ( MCP ) to that machine. The B5000 was unusual at the time in that the architecture and instruction set were designed with

3422-411: 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. An applications version of ALGOL to support the accessing of databases from application programs

3481-649: Was very fast — this impressed the Dutch scientist Edsger Dijkstra 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, Eindhoven University of Technology in the Netherlands. The compiler was fast for several reasons, but the primary reason was that it was a one-pass compiler . Early computers did not have enough memory to store

#651348