DOLPHIN: PERSISTENT, OBJECT-ORIENTED AND NETWORKED A REPORT SUBMITTED TO THE DEPARTMENT OF COMPUTER SCIENCE UNIVERSITY OF STRATHCLYDE CONSISTING OF A DOCTOR OF PHILOSOPHY THESIS DISSERTATION By Gordon W. Russell February 1995 The copyright of this thesis belongs to the author under the terms of the United Kingdom Copyright Acts as qualified by University of Strathclyde Regulation . Due acknowledgement must always be made of the use of any material contained in, or derived from, this thesis. c Copyright 1995 iii Abstract This thesis addresses the problems associated with the design of a new generation of high-performance computer systems for use with object-oriented languages. The major contribution is a novel design for the utilization of object addressing and multiple stacks within RISC-style processors, and a pro- posal for object-addressed stable electronic memory capable of supporting much higher performance than contemporary designs based on the use of disk backing store. The impact of the new designs in discussed and evaluated by simulation within the context of object-oriented system design. iv Publications and Acknowledgements A number of publications have been created from this work: Four machine descriptions and critiques have been reproduced in [Russell and Cockshott, 1993a] from an early draft of chapter 3. This paper is also available as a technical report [Russell and Cockshott, 1993b]. A technical report discussing DAIS' caching strategy has been produced [Russell and Shaw, 1993a]. A cut down version of chapter 5, discussing only the cache structure and its advantages, appears in [Russell et al., 1995]. DAIS' register file is based on a dynamically-resizing shift register. An initial step in the design of this register file, Shifting Register Windows, is available in [Russell and Shaw, 1993b].A version of this paper is available in technical report form [Russell and Shaw, 1993c]. The philosophy behind utilizing Flash cards to implement high-reliability persistence (discussed in chapter 8) is available as a technical report [Cockshott et al., 1993a]. A patent is being prepared to cover the mechanism used in supporting Flash card reliability. An early implementation of MultiThreads, the portable threads library used in the DOLPHIN sub-kernel (chapter 9), is discussed in [Russell, 1993]. Note that from this, MultiThreads has enhanced considerably. I would like to acknowledge the help of Paul Cockshott, my PhD supervisor. His knowledge and understanding has helped greatly to make this document what it is. He also produced initial critiques of two of the five machines investigated in chapter 3, although much of the criticism found therein is now my own. I would also like to thank both Paul Shaw and Robert Lambert; colleagues and fellow PhD Students. Our discussions concerning all of our respective PhD topics has helped to both improve the breadth my of understanding and the quality of the descriptive text produced both in this and other technical documents. v Contents Abstract iii I An Object-Oriented Approach 1 1 Introduction 2 1.1 Overview ......................................... 3 2 Background 5 2.1 Supporting a Persistent Heap . ............................. 7 2.2 Accessing Object-based Data . ............................. 8 2.2.1 Tagging . ..................................... 9 2.2.2 Object Structures and Arrays ........................... 9 3 Object-Oriented Systems 13 3.1 SYSTEM/38........................................ 15 3.1.1 Object Identifiers................................. 15 3.1.2 Object Mapping and Cache Layout . ...................... 16 3.1.3 Conclusions .................................... 18 3.2 iAPX 432 ......................................... 18 3.2.1 Physical Overview . ............................. 20 3.2.2 Object Management . ............................. 21 3.2.3 Performance ................................... 24 3.3MONADS......................................... 25 3.3.1 MONADS Memory Management . ...................... 25 3.3.2 MONADS Segment Capabilities . ...................... 27 3.3.3 Module Management . ............................. 28 3.3.4 MONADS Paging . ............................. 29 3.3.5 Conclusions .................................... 30 3.4 MUTABOR . ..................................... 31 3.4.1 Object Store ................................... 31 vi 3.4.2 Memory Layout ................................. 32 3.4.3 Conclusion .................................... 34 3.5 Rekursiv .......................................... 34 3.5.1 Memory Management . ............................. 36 3.5.2 Object Allocation ................................. 38 3.5.3 Network Addressing . ............................. 39 3.6 Architecture Overview .................................. 39 3.6.1 Summary ..................................... 39 3.6.2 Conclusions .................................... 40 3.7 Directions......................................... 42 II The DOLPHIN Environment 44 4 The DOLPHIN Environment 45 4.1 DOLPHIN ......................................... 46 4.1.1 Design Partitioning . ............................. 46 4.2 Overview ......................................... 46 4.2.1 DAIS . ..................................... 47 4.2.2 Solid-State Backing Store ............................ 50 4.2.3 Lightweight Threads . ............................. 51 4.2.4 Network Packet Transmission .......................... 51 4.2.5 Memory Management . ............................. 52 4.2.6 Networked Object Management . ...................... 52 4.3 Realization of the DOLPHIN Environment . ...................... 53 4.4 Summary ......................................... 54 5 DAIS: An Object-Based Processor Cache 55 5.1 Addressing models .................................... 56 5.1.1 Cached RAM access . ............................. 56 5.1.2 Virtual memory access . ............................. 56 5.1.3 Object Mapping ................................. 57 5.1.4 Comparison to other Systems .......................... 58 5.2DAIS........................................... 60 5.3 Primary Processor Cache ................................. 61 5.4 Primary-Cache Misses .................................. 62 5.5 Benefits of the Object Cache . ............................. 63 5.6 CPI without O-cache ................................... 66 5.7 CPI with the O-cache ................................... 66 5.8 Some Example Figures .................................. 66 5.9 A Networked Object Store . ............................. 68 vii 5.10 DAIS-64 .......................................... 69 5.11 DAIS-256 ......................................... 70 5.11.1 Virtual Mapping of Objects ........................... 72 5.11.2 Performance Effects of Long OIDs . ...................... 73 5.12 Summary ......................................... 73 6 DAIS: A Multiple-Stack Register File 75 6.1 Common Register Windowing Schemes . ...................... 76 6.1.1 Fixed-Sized Register Windows .......................... 76 6.1.2 Variable Register Windows ............................ 77 6.1.3 Design Goals for a Better Windowing Mechanism . .............. 78 6.2 DAIS' Register Stacks .................................. 79 6.2.1 Stack Implementation . ............................. 80 6.2.2 Cache Design ................................... 80 6.2.3 Memory Management for Multiple Stacks .................... 81 6.2.4 Stack Layout ................................... 81 6.3 Analysis .......................................... 82 6.3.1 The Benefit of Asynchronous Transfers ..................... 83 6.3.2 Stack Depth .................................... 84 6.3.3 Stack-Cache Construction ............................ 87 6.3.4 Recommendations . ............................. 88 6.4 Conclusions . ..................................... 90 7 The DAIS Instruction Pipeline 91 7.1 Register Organization ................................... 92 7.1.1 General-Purpose Register Stacks . ...................... 92 7.1.2 Program Counter ................................. 92 7.1.3 User Stack Pointer . ............................. 93 7.1.4 Special Instructions . ............................. 93 7.2 Register Extraction .................................... 93 7.3 Branching......................................... 95 7.4 Pipeline .......................................... 95 7.4.1 Pipeline Efficiency . ............................. 97 7.5 Programming Examples .................................. 97 7.6 LOAD-Induced Data Dependencies ........................... 97 7.6.1 C Language Support . ............................. 98 7.7 Conclusions . ..................................... 99 viii 8 Persistence without Disks 100 8.1 Flash and Operating Systems . .............................101 8.2 Flash-Based Storage ...................................102 8.2.1 ERCA 1 - RAID .................................105 8.2.2 ERCA 2 . .....................................106 8.2.3 ERCA 3 . .....................................108 8.2.4 ERCA 4 . .....................................108 8.2.5 ERCA Classification Summary . ......................115 8.3 Supporting Non-perfect Flash Devices ..........................115 8.4 Flash Store Management .................................117 8.4.1 Block Erasure Limitation .............................118 8.5 Analysis ..........................................118 8.6 Conclusions . .....................................121 9 The Process Environment 123 9.1 MultiThreads . .....................................124 9.1.1 Saving and Restoring Context ..........................124