EXEC II
Unisys History Newsletter
Volume 1, Number 3
March 1993 (revised 1999)
by George Gray
The operating system used today on the 1100 and 2200 Series is an outgrowth of EXEC 8 which was written for the UNIVAC 1108 in the late 1960s, but EXEC 8 was not the first UNIVAC operating system. Its roots go back to EXEC I and EXEC II, which is why in its early years EXEC 8 was often written as EXEC VIII. I found a copy of the EXEC II Programmers Reference for the 1106/1108 (UP-4058 Rev.1), which makes it possible to take a closer look at the early UNIVAC operating systems. In the beginning, computers did not have operating systems. The computer operator set up the computer to run each program. This involved loading the program into memory from magnetic tape, paper tape, or punched cards, and then mounting tapes or loading cards for data input/output. The program itself had to perform all the input/output handling: if it expected the output tape to be on drive 2, then an output tape had better be there. To some degree, this inflexibility could be overcome by switches or jumper cables, but the whole process was very cumbersome, and wasted time between programs.
The early large-scale computers, such as the UNIVAC I and 1103 and the IBM 701 and 704 were very expensive, selling for one or two million dollars, back in the mid-1950s, when, as we well know, a dollar was worth much more than it is now. At most sites, there was no shortage of work to be done, so computer time was a scarce and costly resource. This was one of the factors which opponents of the early higher-level languages cited: with machine time at a premium, the greater size of compiled programs, often five to ten times bigger than an equivalent handcrafted machine language program, was too wasteful. Of course, as the cost of machine time fell relative to programmer time, the power of this argument evaporated. But in the meantime, this scarcity and cost of machine time was a driving force in the development of operating systems. Something had to be done to reduce the time lost between programs, so that more work could be pushed through the computer.
In 1953 at the Eastern Joint Computer Conference several users of the IBM 701 met and discussed the need for some way to streamline the scheduling of computer programs. This led to the first operating system, a batch processing monitor program for the 701 written by programmers at the General Motors Research Center in 1955. The electro- static memory of the 701 was not very reliable, so IBM brought out the core memory 704 as a replacement. The monitor was rewritten for the 704 as a joint effort by General Motors and North American Aviation in 1956. Their GM/NAA I/O System was further developed by the SHARE user group in 1960 as the SHARE Operating System (SOS). Finally, IBM took over support of it, and, with the name changed to IBSYS, it was widely used on the transistor (second-generation) IBM 7090 and 7094 computers. It was not, however, the only operating system for this family of computers. IBM had also developed a FORTRAN monitor system (FMS), Bell Labs wrote a monitor called BELLMON, and the University of Michigan Executive System (UMES) was used at many universities.
These batch processing monitors made it possible to put a series of jobs together on an input tape. The jobs were separated by simple control cards, such as $COMPILE MAD or $DATA, to indicate functions to be performed or the location of data. Time on the 7090 was frequently seen as too valuable to be taken up with card processing or printing, so quite often these tasks were handled by some smaller, cheaper computer, typically an IBM 1401. The input job streams and card data were written to tape on the 1401, and then the tapes were taken to the 7090. Output was done in reverse: the 1401 received tapes from the 7090, and did the printing or card punching. This arrangement was a good deal for the IBM salesmen, because they got to sell (or lease) two computers instead of one!
UNIVAC's announcement of the 1107 in December 1960 was very late. By that time the first IBM 7090 had been in the field for a year, and over a dozen more had been shipped since then, while the first Philco Transac 2000 and Control Data 1604 computers were installed in early 1960. The announced delivery date for the 1107 was late 1961, but due to various development problems, the first one was not completed until September 1962. To have any marketplace advantage at all, UNIVAC would have to offer a superior product. The operating system software was one area in which UNIVAC tried to do better.
UNIVAC's systems programming group in St. Paul started work on an operating system for the 1107, which eventually became known as EXEC I. It was written in the assembly language (known as SLEUTH) of the 1107, comprised some 25,000 lines of code, and occupied about 8K of the 1107's 32K of memory. It was intended to support true multi-programming: sharing CPU time among several batch runs. This would permit the use of on-line utility programs to do the card-to-tape and tape-to-print/punch work which the IBM 7090 sites were doing off-line. EXEC I was to be more sophisticated than batch monitors, since it would schedule CPU time, allocate memory, and queue i/o requests. Processing was interrupt- driven, using i/o completion or clock timing, to force programs to relinquish control of the CPU. The control algorithm was simple: each program was classified as either compute-bound or i/o-bound, and the EXEC kept a first-in first-out queue for each class. Each program execution within a run was scheduled independently, so the programmer had to supply cards describing the resources (core, tape, drum, reader, or printer) that it needed.
These would start out with the PTY (for priority) card which gave the job a name (one to six characters in length), told what program would be run and where it was stored (drum or tape), stated a priority, and indicated whether the program was compute-bound or i/o-bound. Following the PTY card, there would be FAC cards describing each facility (memory area, tape drive, printer, card punch, etc.) needed by the program. For example:
BAKER,PTY,R,THE-PAYROLL,T,P
described a job called BAKER with a rush priority (R) running the program THE-PAYROLL, which was stored on UNISERVO IIIA tape (T) and was i/o bound (P). This would be followed by various FAC cards, such as:
BAKER,FAC,IB/2,DB/3
which stated that the program would need two contiguous 2048-word memory areas for its instructions (IB) and three for its data area (DB). The complexity of these statements made EXEC I difficult to use. Putting together a whole runstream took a lot of work.
The early 1960s were a difficult time for Sperry Rand, and the company did not have the resources to do all of its software development in-house. For the 1107, UNIVAC wrote EXEC I and SLEUTH, but the ALGOL, COBOL, and FORTRAN compilers were contracted out. The contract for COBOL went to Computer Sciences Corporation (CSC), which had already produced a FORTRAN compiler for UNIVAC's LARC computer and was also writing much of the software for the UNIVAC III, the UNIVAC Philadelphia division's business computing counterpart to the 1107. Very probably there was some kind of barter involved, since CSC received the first 1107 shipped by UNIVAC.
EXEC I wasn't ready yet, so CSC went ahead and devised its own operating system for the 1107, which became EXEC II. CSC stretched the terms of their contract a good bit: when the COBOL compiler was finished, it was for an EXEC II environment, not EXEC I! CSC designed EXEC II to be a serial batch processing system, with a multiprogramming capability limited to the handling of card input and printer output. This still gave it an edge over the IBM 7090 monitors, without introducing the complexities of EXEC I. EXEC II made extensive use of the FH-880 drum for staging card input and printed output, as well as for temporary storage of program files read in from tape. Keep in mind that at this time disk (as opposed to drum) technology was very new, and UNIVAC had no disks. Not until 1970 was a disk drive, the 8414, supported on the 1100 Series. The drums of the early 1960s did not have enough capacity to accommodate long-term storage of program files. Therefore, programs were usually kept on tape or card.
EXEC II was composed of resident routines which stayed in memory at all times, and non-resident ones which were brought in from drum only when needed. The resident routines included a minimal control card interpreter, a jump vector for user program entries into EXEC II, configuration tables, file directory handlers, and control routines for drum, tape, and console. There was also a dispatcher routine to control i/o queues. The major non-resident routines were the main control card interpreter, job accounting, and the routines to control card and print i/o. This last group of routines for card and print was called the symbiont routines. In the later years of EXEC II, there were symbiont routines for data interchange with remote or on-site UNIVAC 1004 or 9300 computers. The term symbiont referred to the symbiotic relationship between the computer's central complex and the peripheral devices.
EXEC II was bigger than EXEC I, comprising 45,000 lines of assembler code and occupying 12K of memory. The command language was easier to use than that of EXEC I, and was the basis for the Executive Control Language (ECL) used in EXEC 8. The major difference in syntax is that in EXEC II, the options field came first (immediately after the @) instead of after the operation field. For example, a call to the COBOL compiler to compile input source element BING, putting the updated source output in BONG and the relocatable object output in TICK/TOCK would be:
@SX COB BING, BONG, TICK/TOCK
The S option said to punch the source output on cards and the X to abort the compilation if errors were detected. Incidentally, the names BING, BONG, and TICK/TOCK are taken from an example in the EXEC II Programmers Reference. Many statements had essentially the same meaning in EXEC II as they would have in EXEC 8, including:
RUN run initiation
FIN run termination
XQT program execution
MSG console message
ASG facilities assignment
PMD postmortem dump
ELT input cards into program file
HDG heading for print pages
EXEC II provided a tape file structure called a PCF (program complex file) for source, relocatable, and absolute program elements. Manipulation of program elements was done through a set of routines called CUR (complex utility routines) which was the ancestor of EXEC 8's FURPUR processor. CUR was called via an @XQT CUR, followed by directives on subsequent cards. A few of the directives, such as ERS, FIND, and PCH were carried over directly into FURPUR. Other processors which came with EXEC II were:
ALG ALGOL Compiler
ASM Assembler (SLEUTH)
COB COBOL Compiler
FOR FORTRAN Compiler
LFT LIFT: a FORTRAN II to FORTRAN IV conversion routine
The ALGOL compiler was written at Case Institute of Technology, as part of an arrangement whereby it received an 1107 to replace its old UNIVAC I.
As a result of its late appearance, only 36 1107s were sold, but fortunately UNIVAC was prompt in announcing and delivering its third generation 1108 computer. It was fully compatible with the 1107, so that all the software, including EXEC II, could be carried over to it, and EXEC II had several years of glory on the 1108. An article titled "Conversion at Lockheed Missiles and Space" in the January 1967 issue of Datamation said that Lockheed found that "The FORTRAN IV compiler and EXEC II Operating System were considerably more powerful and of better design than their counterparts on the IBM 7094." Using an 1107 as an interim machine, Lockheed ultimately replaced two 7094s with two 1108s.
During its later years, there were two major enhancements to EXEC II. The first was the capability to use a remote 1004 computer as an input-output device. This was apparently the outgrowth of work done by UNIVAC on one of the Bogart computers it made for the National Security Agency. The second was the incorporation of the FASTRAND drum as a mass storage device for permanent program and data files.
While both EXEC I and EXEC II were provided for the 1108, it was clear that the two should be merged to provide a true multi-programming system with the ease of use and external appearance of EXEC II. This was EXEC 8. The specifications for it were drawn up in December 1964 and work began in May 1965.
But that is another story. EXEC I and EXEC II were significant developments in the evolution of operating systems. Though not as sophisticated as the Master Control Program (MCP) for the Burroughs 5000 and the Compatible Time Sharing System (CTSS) developed at MIT for the IBM 7090, the EXECs did represent an advance over the batch monitors of their time. They demonstrated that an operating system more complex than the IBM monitors could achieve a high level of throughput.
Trademarks.
Unisys, UNIVAC, FASTRAND, and UNISERVO are registered trademarks of Unisys Corporation. Copyright 1993, 1999 by George Gray
