Wikipedia

IBM CP-40

(Redirected from CP-40)

CP-40 was a research precursor to CP-67, which in turn was part of IBM's then-revolutionary CP[-67]/CMS – a virtual machine/virtual memory time-sharing operating system for the IBM System/360 Model 67, and the parent of IBM's VM family. CP-40 ran multiple instances of client operating systems – particularly CMS, the Cambridge Monitor System,[1] built as part of the same effort. Like CP-67, CP-40 and the first version of CMS were developed by IBM's Cambridge Scientific Center (CSC) staff, working closely with MIT researchers at Project MAC and Lincoln Laboratory. CP-40/CMS production use began in January 1967. CP-40 ran on a unique, specially modified IBM System/360 Model 40.

CP-40
DeveloperIBM Cambridge Scientific Center (CSC)
OS familyCP/CMS
Working stateHistoric
Initial releaseJanuary 1967; 57 years ago (1967-01)
Marketing targetIBM mainframe computers
Available inEnglish
PlatformsA unique, specially modified IBM System/360 Model 40
Default
user interface		Command-line interface
LicenseProprietary
Succeeded byCP-67

Project goals

edit

CP-40 was a one-off research system. Its declared goals were:

  • Provide research input to the System/360 Model 67 team working in Poughkeepsie, who were breaking new ground with the as-yet-unproven concept of virtual memory.
  • Support CSC's time-sharing requirements in Cambridge.

However, there was also an important unofficial mission: To demonstrate IBM's commitment to and capability for supporting time-sharing users like MIT. CP-40 (and its successor) achieved its goals from technical and social standpoints – they helped to prove the viability of virtual machines, to establish a culture of time-sharing users, and to launch a remote computer services industry. The project became embroiled in an internal IBM political war over time-sharing versus batch processing; and it failed to win the hearts and minds of the academic computer science community, which ultimately turned away from IBM to systems like Multics, UNIX, TENEX, and various DEC operating systems. Ultimately the virtualization concepts developed in the CP-40 project bore fruit in diverse areas, and remain important today.

Features

edit

CP-40 was the first operating system that implemented complete virtualization, i.e. it provided a virtual machine environment supporting all aspects of its target computer system (a S/360-40), such that other S/360 operating systems could be installed, tested, and used as if on a stand-alone machine. CP-40 supported fourteen simultaneous virtual machines. Each virtual machine ran in "problem state" – privileged instructions such as I/O operations caused exceptions, which were then caught by the control program and simulated. Similarly, references to virtual memory locations not present in main memory cause page faults, which again were handled by control program rather than reflected to the virtual machine. Further details on this implementation are found in CP/CMS (architecture).

The basic architecture and user interface of CP-40 were carried forward into CP-67/CMS, which evolved to become IBM's current VM product line.

Hardware platform

edit

A Model 67 was not available for building CP-40, so a custom virtual memory device based on associative memory (the "CAT box"[2]) was designed and built for CSC. It involved both hardware and microcode changes to a specially modified System/360 Model 40. These changes gave the unit the technology needed for full virtualization of the System/360 hardware. This modified Model 40 influenced the design of the forthcoming Model 67, which was intended to meet the needs of the same community of time-sharing users (notably MIT's Project MAC and Bell Laboratories – though both of these sites became notable IBM sales failures).

Three distinct virtual memory systems were implemented by IBM during this period:

  • The "Blaauw Box" (named for Gerry Blaauw), part of the original design of the S/360-67
  • The "CAT Box" (Cambridge Address Translator), added to CSC's S/360-40 to run CP-40
  • The "DAT Box" (Dynamic Address Translation), announced as an addition to the S/370 series in 1972

These systems were all different, but bore a family resemblance. CP-40's CAT box was a key milestone. Pugh et al.[3] cite an IEEE paper[4] about the CP-40 virtual memory hardware, and states that it was "unique in that it included a parallel-search register bank to speed dynamic address translation. With funds supplied by Cambridge, IBM engineer[s]... built a 64-register associative memory and integrated it into a 360/40. The one-of-a-kind result was shipped to Cambridge early in 1966."

Although virtualization support was an explicit goal for CSC's modified Model 40, this was not apparently the case for the original Model 67 design. The fact that virtualization capabilities were ultimately implemented in the -67, and thus enabled the success of CP-67/CMS, speaks to the tenacity and persuasiveness of the CSC team.

CMS under CP-40

edit

CMS was first built in 1964 at CSC to run as a "client" operating system under CP-40. The CMS project leader was John Harmon. Although any S/360 operating system could run in a CP-40 virtual machine, it was decided that a new, simple, single-user interactive operating system would be best for supporting interactive time-sharing users. This would avoid the complexity and overhead of running a multi-user system like CTSS. (Contrast this with IBM's OS/MVT-TSO and its successors – essentially a time-sharing operating system running as a single task under an IBM batch operating system. With CMS, each interactive user gets a private virtual machine.)

By September 1965, many important CMS design decisions had already been made:

  • User-friendly commands, with default-mode, non-required parameters wherever possible (for ease of use and training, and to minimize job control requirements)
  • A basic set of file system commands and macros; a simple file naming convention, based on filename, filetype, and filemode (filemode = logical disk identifier or minidisk, a form of drive letter assignment)
  • Records mapped to fixed-size blocks, that could be read or written by relative record number
  • Files that could be created simply by writing to them, without the need for special 'create' operations
  • Default filemodes, allowing disks to be searched in a fixed order

These were radical departures from the difficult file naming, job control (via JCL), and other requirements of IBM's "real" operating systems.[5] (Some of these concepts had been goals for operating systems from other vendors, such as Control Data Corporation and DEC.)

The CMS file system design, with its flat directory structure, was kept deliberately simple. Creasy notes: "This structure of multiple disks, each with a single directory, was chosen to be simple but useful. Multi-level linked directories, with files stored in common areas, had been the design trend when we began. We simplified the design of this and other components of CMS to reduce implementation complexity."[6]

Application programs running under CMS executed within the same address space. They accessed system services, such as the CMS file system, through a simple programming interface to the CMS nucleus, which resided in low memory within the CMS virtual machine. A variety of system calls were provided, most of which would be familiar to current CMS programmers. (Since applications ran in the CMS virtual machine, they could potentially misbehave, by overwriting CMS data, using privileged instructions, or taking other actions that could take over or crash the virtual machine. Of course, doing so could not affect other virtual machines, which were all mutually isolated; nor could it damage the underlying control program. Unlike most operating systems, CP crashes rarely stemmed from application errors – and were thus themselves relatively rare.)

Historical notes

edit

The following notes provide brief quotes, primarily from Pugh, Varian, and Creasy [see references], illustrating the development context of CP-40. Direct quotes rather than paraphrases are provided here, because the authors' perspectives color their interpretations. Also see History of CP/CMS for additional context.

  • Genesis of the CP-40 project:
    • CSC's Rasmussen felt "very dubious" about TSS/360 and decided that his idle CSC resources should be put to use creating a "credible time-sharing system for the S/360", which became known as CP-40. Project leader was Robert Creasy, who had been a CTSS programmer.[7]
    • CP-40 goals included both conducting research (obtaining and analyzing data about systems and software, including the use of associative memory) and meeting CSC's own computing requirements via time-sharing. Varian adds: "The project's real purpose was to build a time-sharing system, but the other objectives were genuine, too, and they were always emphasized in order to disguise the project's "counter-strategic" aspects." Creasy describes CP/CMS goals this way: It was to be "a second-generation time-sharing system for the newly announced IBM System/360 ... [that would] support all the activities of the Cambridge center, including such diverse activities as operating system research, application development, and report preparation by programmers, scientists, secretaries, and managers. Soon after its inception, it was convenient for the system to be recognized and financially supported from outside of the center as a tool to evaluate and test the performance of operating systems."[8]
    • CSC's research was important to IBM, because at the time, "not much was really known about virtual memory systems." Varian quotes L.W. Comeau: "[IBM's] commitment to virtual memory was backed with no successful experience.... What was frightening is that nobody who was setting this virtual memory direction at IBM knew why [the contemporary virtual memory system Ferranti] Atlas didn't work." (Comeau later concluded that the Atlas had suffered from thrashing, which was not studied until it was observed on the IBM M44/44X and on CP-40.)[9][10]
  • CP-40 design: Pugh et al. write that: "In 1964... IBM Research were recommending the use of virtual-machine principles to time-sharing planners... [which were] picked up by the Cambridge [CSC] team, who wanted, among other things, a system capable of testing operating systems." A key design decision, made by Creasy and Comeau at the end of 1964, was to base CP-40 not just on virtual memory but on virtual machines (at first called pseudo-machines, until the later term was appropriated from the IBM M44/44X project – which Creasy describes as having "similar but independent ideas."[11] Creasy provides a clear description of CP's virtualization strategy, based on the S/360 instruction set, which consisted of privileged "supervisor state" instructions distinct from normal "problem state" instructions: "Each [CP] virtual machine program is actually executed [entirely] in problem state.... Privileged instructions... [are] reproduced by CP within the virtual machines...." By running an OS in problem state, all the "tricky" instructions would automatically be intercepted by the hardware. This left just one main virtualization problem: memory references. "Experience [with CTSS]... suggested the need for dynamic program relocation... to break programs into pieces which could be moved into, out of, and within the memory independently of each other."[12]
  • CP-40 virtual machines:
    • Earlier research projects involving the virtual machine concept, such as the IBM M44/44X, had not attempted to create an exact virtual duplicate of a real machine. Creasy: "[They were] close enough... to prove that 'close enough' did not count."
    • CP-40 took the bold step of full virtualization, creating fourteen virtual S/360 environments, each with a fixed virtual memory size of 256K, mapped access to disk partitions, and spooled access to unit record devices (e.g. printers). Comeau: "[Creating full virtualization] permitted simultaneous development of CP and CMS; it allowed us to measure non-virtual systems, OS and DOS, in a virtual memory environment, and it also provided a high level of integrity and security."[13][14]
    • In addition to revealing the value of full virtualization, the experimental IBM M44/44X "implanted the idea that the virtual machine concept is not necessarily less efficient than more conventional approaches" – a core assumption in the CP-40 architecture, and one that ultimately proved very successful.[15]
    • CP-40 would soon support "up to a dozen virtual System/360 machines" under terminal control [most sources state fourteen]. (CP-67 later "exploited... address-translation... and increased speed... to double the capacity" of CP-40.[16])
  • CMS under CP-40:
  • About the decision to separate CMS and CP, Creasy writes: "The implementation of CTSS illustrated the necessity of modular design for system evolution. Although successful as a production system, the interconnections and dependencies of its supervisor design made extension and change difficult. A key concept of the CP/CMS design was the bifurcation of computer resource management and user support. In effect, the integrated design [of CTSS] was split into CP and CMS." The value of experience gained on the CTSS project cannot be overstated.[17]
  • About early CMS, Creasy writes: CMS "provided single user service unencumbered by the problems of sharing, allocation, and protection."[18] Early CMS development involved booting CMS under BPS, an early S/360 support system, until CMS was far enough along to boot stand-alone. Eventually development moved to virtual machines under CP.[19]

See also

edit

References

edit
  1. ^ Control Program-67/Cambridge Monitor System (GH20-0857-1). IBM. October 1971.
  2. ^ Varian (1997), p. 11 (the "CAT box")
  3. ^ Pugh, Johnson & Palmer (1991), p. 741 (note 218 to Ch. 6)
  4. ^ A.B. Lindquist; R.R. Seeber; L.W. Comeau (December 1966). "A time-sharing system using an associative memory". Proceedings of the IEEE. 54 (12): 1774–1779. doi:10.1109/PROC.1966.5261.
  5. ^ Varian (1997), p. 14 – novelty of CMS interface
  6. ^ Creasy (1981), p. 489 – flat file system
  7. ^ Varian (1997), pp. 3, 9, 16 – genesis of CP-40 project
  8. ^ Creasy (1981), p. 485 – design goals
  9. ^ W. O'Neill, "Experience using a time sharing multiprogramming system with dynamic address relocation hardware", Proc. AFIPS Computer Conference 30 (Spring Joint Computer Conference, 1967), pp. 611–621 – thrashing on IBM M44/44X
  10. ^ L.W. Comeau, "Operating System/360 Paging Studies", IBM Storage Hierarchy System Symposium, December 1966 – thrashing on the Atlas, cited in Varian (1997), p. 17.
  11. ^ Creasy (1981), p. 485 – similar to but independent of IBM M44/44X
  12. ^ Creasy (1981), p. 486 – virtualization strategy: problem state execution, plus address translation
  13. ^ Varian (1997), pp. 9, 13
  14. ^ Comeau (1982), pp. 40, 42–43, cited in Varian (1997), pp. 9, 13
  15. ^ L. Talkington, "A Good Idea and Still Growing", White Plains Development Center Newsletter, Vol. 2, No. 3 (March 1969), quoted in Varian (1997), p. 10.
  16. ^ Pugh, Johnson & Palmer (1991), pp. 364–365
  17. ^ Creasy (1981), p. 485 – separating CP from CMS
  18. ^ Creasy (1981), p. 485 – scope of CMS
  19. ^ Varian (1997), pp. 12, 15–16 – CMS booting under BPS

Further reading

edit

Family tree

edit
CP/CMS family relationships
→ derivation     >> strong influence     > some influence/precedence
 CTSS 
> IBM M44/44X
>> CP-40/CMS → CP[-67]/CMS  → VM/370 → VM/SE versions → VM/SP versions → VM/XA versions → VM/ESA → z/VM
→ VP/CSS
> TSS/360
> TSO for MVT → for OS/VS2 → for MVS → ... → for z/OS
>> MULTICS and most other time-sharing platforms
Retrieved from "https://en.wikipedia.org/w/index.php?title=IBM_CP-40&oldid=1212327985"