Persistent object stores

The design and development of a type secure persistent object store is presented as part of an architecture to support experiments in concurrency, transactions and distribution. The persistence abstraction hides the physical properties of data from the programs that manipulate it. Consequently, a persistent object store is required to be of unbounded size, infinitely fast and totally reliable. A range of architectural mechanisms that can be used to simulate these three features is presented. Based on a suitable selection of these mechanisms, two persistent object stores are presented. The first store is designed for use with the programming language PS-algol. Its design is evolved to yield a more flexible layered architecture. The layered architecture is designed to provide each distinct architectural mechanism as a separate architectural layer conforming to a specified interface. The motivation for this design is two-fold. Firstly, the particular choice of layers greatly simplifies the resulting implementation and secondly, the layered design can support experimental architecture implementations. Since each layer conforms to a specified interface, it is possible to experiment with the implementation of an individual layer without affecting the implementation of the remaining architectural layers. Thus, the layered architecture is a convenient vehicle for experimenting with the implementation of persistent object stores. An implementation of the layered architecture is presented together with an example of how it may be used to support a distributed system. Finally, the architecture's ability to support a variety of storage configurations is presented.

[1]  Elliott I. Organick,et al.  Computer System Organization: The B5700/B6700 Series , 1973 .

[2]  Ansi Ieee,et al.  IEEE Standard for Binary Floating Point Arithmetic , 1985 .

[3]  David A. Patterson,et al.  RISC assessment: A high-level language experiment , 1982, ISCA.

[4]  Maurice V. Wilkes.  Hardware support for memory protection: Capability implementations , 1982, ASPLOS I.

[5]  William A. Wulf,et al.  HYDRA , 1974, Commun. ACM.

[6]  Henry M. Levy.  The IBM System/38 , 1984 .

[7]  Ken Thompson,et al.  The UNIX time-sharing system , 1974, CACM.

[8]  John McCarthy,et al.  Recursive functions of symbolic expressions and their computation by machine, Part I , 1959, Commun. ACM.

[9]  Brian Randell,et al.  A note on storage fragmentation and program segmentation , 1969, CACM.

[10]  Raymond A. Lorie,et al.  Physical integrity in a large segmented database , 1977, TODS.

[11]  Alan Dearle,et al.  Implementation issues in persistent graphics , 1986 .

[12]  C. Whitby-Strevens,et al.  BCPL, the language and its compiler , 1979 .

[13]  Renzo Orsini,et al.  GALILEO: a strongly-typed, interactive conceptual language , 1985, TODS.

[14]  Kenneth C. Knowlton,et al.  A fast storage allocator , 1965, CACM.

[15]  Butler W. Lampson,et al.  Crash Recovery in a Distributed Data Storage System , 1981 .

[16]  B. J. Mailloux,et al.  Report of Algorithmic Language ALGOL 68 , 1969 .

[17]  Alan Dearle,et al.  On the construction of persistent programming environments , 1988 .

[18]  David Ungar.  Generation scavenging: a nondisruptive high performance storage reclamation algorithm , 1984 .

[19]  Liba Svobodova.  File servers for network-based distributed systems , 1984, CSUR.

[20]  David M. Ungar,et al.  Generation Scavenging: A non-disruptive high performance storage reclamation algorithm , 1984, SDE 1.

[21]  James Leslie Keedy,et al.  Object Management and Addressing in the MONADS Architecture , 1987, POS.

[22]  Robert S. Fabry.  The Case for Capability-Based Computers. , 1973, SOSP 1973.

[23]  Jacques Cohen,et al.  Garbage Collection of Linked Data Structures , 1981, CSUR.

[24]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[25]  Ronald Morrison,et al.  Persistent object management system , 1984, Softw. Pract. Exp..

[26]  Irving L. Traiger,et al.  The Recovery Manager of the System R Database Manager , 1981, CSUR.

[27]  Ronald Morrison,et al.  An Approach to Persistent Programming , 1989, Comput. J..

[28]  Robert Fenichel,et al.  A LISP garbage-collector for virtual-memory computer systems , 1969, CACM.

[29]  Friedrich L. Bauer,et al.  Revised report on the algorithm language ALGOL 60 , 1963, CACM.

[30]  John McCarthy,et al.  Recursive functions of symbolic expressions and their computation by machine, Part I , 1960, Commun. ACM.

[31]  Renzo Orsini,et al.  The Type System of Galileo , 1988, Data Types and Persistence , Informal Proceedings.

[32]  Shreekant Thakkar,et al.  A high-performance memory management scheme , 1986 .

[33]  George D. M. Ross.  Virtual files : a framework for experimental design , 1983 .

[34]  A. Retrospective,et al.  The UNIX Time-sharing System , 1977 .

[35]  David A. Patterson,et al.  RISC assessment: A high-level language experiment , 1982, ISCA 1982.

[36]  Malcolm P. Atkinson,et al.  CMS—A chunk management system , 1983, Softw. Pract. Exp..

[37]  Andrew S. Tanenbaum,et al.  Distributed operating systems , 2009, CSUR.

[38]  John F. Wakerly,et al.  The programming language PASCAL , 1979, Microprocessors and microsystems.

[39]  BabaogluÖzalp,et al.  Converting a swap-based system to do paging in an architecture lacking page-referenced bits , 1981 .

[40]  John A. Fotheringham,et al.  Dynamic storage allocation in the Atlas computer, including an automatic use of a backing store , 1961, Commun. ACM.

[41]  Malcolm P. Atkinson.  Programming Languages and Databases , 1978, VLDB.

[42]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

[43]  Stanley E. Myers.  RPG II and RPG III with Business Applications , 1983 .

[44]  Peter J. Denning,et al.  Virtual memory , 1970, CSUR.

[45]  John Rosenberg,et al.  MONADS-PC - a capability-based workstation to support software engineering , 1985 .

[46]  David Hough,et al.  Applications of the Proposed IEEE 754 Standard for Floating-Point Arithetic , 1981, Computer.

[47]  Warren Teitelman,et al.  The interlisp reference manual , 1974 .

[48]  Roy Levin,et al.  HYDRA Basic Kernel Reference Manual. , 1976 .

[49]  Dileep Bhandarkar,et al.  VAX floating point: a solid foundation for numerical computation , 1980, CARN.

[50]  Jerome H. Saltzer,et al.  A hardware architecture for implementing protection rings , 1972, CACM.

[51]  J. K. Buckle.  The ICL 2900 series , 1978 .

[52]  D. Stevenson.  A Proposed Standard for Binary Floating-Point Arithmetic , 1981, Computer.

[53]  Jack B. Dennis,et al.  Virtual memory, processes, and sharing in Multics , 1967, CACM.

[54]  Tom Kilburn,et al.  One-Level Storage System , 1962, IRE Trans. Electron. Comput..

[55]  Jean E. Sammet.  Basic elements of COBOL 61 , 1962, CACM.

[56]  William J. Cody.  Analysis of Proposals for the Floating-Point Standard , 1981, Computer.

[57]  J. Darlington,et al.  Functional Programming and its Applications: An Advanced Course , 1982 .

[58]  George W. Struble.  Assembler Language Programming: The IBM System 360 , 1975 .

[59]  G. Lawrence Krablin.  Building Flexible Multilevel Transactions in a Distributed Persistent Environment , 1985, Data Types and Persistence , Informal Proceedings.

[60]  Abraham Silberschatz,et al.  Operating System Concepts , 1983 .

[61]  Richard C. H. Connor,et al.  The Persistent Abstract Machine , 1989, POS.

[62]  Satish M. Thatte,et al.  Persistent Memory: A Storage Architecture for Object-Oriented Database Systems , 1986, OODBS.