John Iliffe (computer designer)

From Wikipedia the free encyclopedia

John Kenneth Iliffe
Portrait
Born(1931-09-18)18 September 1931
London
Died16 February 2020(2020-02-16) (aged 88)[3]
NationalityBritish
Alma materSt. John's College, University of Cambridge
Known forDesign of computer systems with secure object management and fine-grained program protection; the Iliffe vector storage structure
AwardsIEEE Computer Society Harry H. Goode Memorial Award,[1] 2000 [2]
Scientific career
InstitutionsRice University, Houston, Texas

International Computers Limited Queen Mary University of London, UK

Imperial College London, UK

John Kenneth Iliffe (18 September 1931 – 16 February 2020) was a British computer designer who worked on the design and evaluation of computers that supported fine-grained memory protection and object management. He implemented, evaluated and refined such designs in the Rice Institute Computer, R1 (1958–61) and the ICL Basic Language Machine (1963–68).[4][5] A key feature in the architectures of both machines was control by the hardware of the formation and use of memory references so that the memory could be seen as a collection of data objects of defined sizes whose integrity is protected from the consequences of errors in address calculation, such as overrunning memory pointers (whether by accident or malicious intent).[6]

Technical contributions[edit]

Iliffe attended the EDSAC programming course in Cambridge in 1952. He eventually learned about computing by running the IBM (UK) service bureau in London. In 1958 he was invited to join the team building the R1 computer at Rice Institute, Houston, in which he took responsibility for operating system and language design and implementation.[7] In the next 30 years he put into operation four computers demonstrating and evaluating new concepts in design.

The Rice R1 Computer[edit]

Main article: Rice Institute Computer

Iliffe led the development of the operating system and programming language for the Rice Computer. His design included an early instance of dynamic memory allocation and management, enabling programs to acquire storage on demand and automatically recover it when it was no longer accessible.[8][9]

In the R1[7] Iliffe and his colleagues introduced a protection scheme for all data objects. The manipulation of references to memory (termed codewords) was restricted to privileged code, preventing some types of program error. Codewords referenced vectors of data items, sequences of instructions or other codewords . Storage was accessed by reference to a codeword and this was resolved to a conventional address or program counter giving direct access to store when necessary. The system provided functions to create, manage and update codewords, for example changing them to reflect storage management decisions. It also supported an algebraic programming language (called Genie) which was implemented using object-oriented design concepts in 1961.[10] The Genie compiler and associated assembler were unusual in enabling the entire system to be treated as an object-management discipline. Genie was also amongst the first languages to include intrinsic operations on real and complex vectors and matrices.

The well-known Iliffe vector storage structure for multi-dimensional and irregular arrays emerged from the R1 work. It exploits a similar addressing structure but without system enforcement.

The Basic Language Machine[edit]

In the early 1960s there was a strong requirement for general-purpose computers to provide for the concurrent execution of multiple user programs, both in the form of multiprogramming to optimise the use of a computer's resources and in the form of time-sharing to enable interactive computing. Both of these require a computer architecture in which the operating system could guarantee the separation, security and integrity of several concurrently-running programs. It seemed clear that the simplified model of architecture derived from the Princeton IAS and followed by all the “von Neumann” models would run into severe difficulties in satisfying that requirement.

The Basic Language Machine (BLM),[5] constructed and evaluated in the research department of International Computers Limited (ICL) between 1963 and 1968[11] was the first general-purpose system to break completely with the Von Neumann architecture. Instead of basing the architecture on a single linear address space, the BLM offered segmented memory addressing, enabling automatic storage management and access within precise security boundaries.

Iliffe took the engineering view that it should be possible to offer a way, based on the memory management techniques already demonstrated in the Rice R1 to ensure the integrity of concurrent programs without resorting to relatively expensive mechanisms involving the frequent swapping of process state vectors seen in most other systems. He developed a design based on the use of codewords to represent all memory references. A codeword included a base address, a limit specifying the length of a data object and some type information. The internal representation of codewords was opaque to user programs but specific machine instructions were provided to manipulate them in ways that maintained the data structure. That represented a substantial refinement of the Rice R1 architecture, providing for the efficient management of multiple processes, each having a separate tree-structured data and instruction store.

The Rice R1 and the BLM were examples of descriptor-based computer architectures that emerged in the 1960s[6] aimed both at the efficient protection of concurrently-executing programs and the reliable implementation of high-level languages. The other major example was the B5000 series of computers developed and marketed by the Burroughs Corporation. All these descriptor-based computers included hardware mechanisms designed to support the reliable addressing of data segments. They are closely related to capability-based architectures[6] that emerged a few years later.

In parallel with construction of the BLM a separate evaluation team assessed it in terms of (1) program efficiency (2) operating characteristics (3) coding and debugging costs and (4) system overheads. For meaningful comparison, legacy high-level languages (Cobol, Fortran, file management) were used. It was shown that despite the precision of the addressing mechanism there was no noticeable loss of efficiency or additional system overhead.

Levy[6] discusses the wider impact of descriptor-based computer architectures with reference to both the Burroughs B5000 and the BLM (p. 38) "... whether or not they were long-lived, these machines demonstrated the feasibility of using descriptors and segmentation to greatly increase programming flexibility for the user, the compilers, and the operating system". Levy also notes that "an excellent discussion of the BLM within the context of modern capability systems appears in Iliffe's Advanced Computer Design[12]".

The BLM design was rejected by ICL management in an internal review of options to select a new architecture for ICL's mainframe products in December 1969.[13]

In the year 2000 Iliffe received the IEEE Harry H. Goode Memorial Award "For lifetime achievement in the practice of computer system design and evaluation."

Changes in semiconductor technology in the 30 years following the development of the BLM led to refinements of the architecture. In the absence of research funding they were evaluated mainly by simulation using low-cost microprocessors and Iliffe's Advanced Computer Design[12] describes them in some detail.

Personal life[edit]

  • Education: Carpenter Scholarship to City of London School (1945–1948). Mathematical Tripos at St John's College, Cambridge 1949–1952.
  • Service: Royal Navy 1953–1956. Instructor Lieutenant.
  • Sports: President of Otter Swimming Club 1990–1996.
  • Iliffe was married to Dorothy Bannister 1955–2015 (her death). They had three children: Louise, Jonathan and Kate.

References[edit]

  1. ^ "Harry H. Goode Memorial Award | IEEE Computer Society".
  2. ^ "John Iliffe | IEEE Computer Society".
  3. ^ City of London School: John Kenneth Iliffe, Class of 1948
  4. ^ Iliffe, J. K. (1 August 1969). "Elements of BLM". The Computer Journal. 12 (3): 251–258. doi:10.1093/comjnl/12.3.251. ISSN 0010-4620.
  5. ^ a b Iliffe, J.K. (1968). Basic Machine Principles. London: MacDonald. ISBN 9780356023274.
  6. ^ a b c d Levy, Henry M. (1984). Descriptor-Based Computer Systems. Digital Press. Retrieved 8 May 2019. Chapter 2 Early Descriptor Architectures, Chapter 3 Early Capability Architectures
  7. ^ a b Thornton, Adam. "A Brief History of the Rice Computer 1959-1971". Archived from the original on 24 February 2008. Retrieved 13 March 2019. (mostly written in [or before] 1994, and archived by the Wayback Machine on a date indicated [by "20080224"] in the URL)
  8. ^ Iliffe, J.K. (23 January 1969). Store Management Techniques. Edward Feustel collection on the Rice University Computer Project. Retrieved 9 June 2019. {{cite book}}: |website= ignored (help)
  9. ^ Iliffe, J. K.; Jodeit, Jane G. (1 November 1962). "A Dynamic Storage Allocation Scheme". The Computer Journal. 5 (3): 200–209. doi:10.1093/comjnl/5.3.200. ISSN 0010-4620.
  10. ^ J.K. Iliffe (1961). The Use of The Genie System in Numerical Calculations. Annual Review in Automatic Programming. Vol. 2. Elsevier Science. pp. 1–28. ISBN 978-1-4832-2282-0. Retrieved 13 March 2019.
  11. ^ Scarrott, Gordon (1995). "From Torsional Mode Delay Lines to DAP". Computer Resurrection. 12 (Summer 1995). ISSN 0958-7403. Retrieved 8 May 2019.
  12. ^ a b Iliffe, J.K. (1982). Advanced Computer Design. Prentice Hall. ISBN 978-0130112545.
  13. ^ Buckle, J. K. (1978). The ICL 2900 series (PDF). MacMillan. ISBN 978-0333219171.

Further reading[edit]

Retrieved from "https://en.wikipedia.org/w/index.php?title=John_Iliffe_(computer_designer)&oldid=1197923017"