Extensible virtual machines

Virtual machines (s) have enjoyed a resurgence as a way of allowing the same application program to be used across a range of computer systems. This flexibility comes from the abstraction that the  provides over the native interface of a particular computer. However, this also means that the application is prevented from taking the features of particular physical machines into account in its implementation. This dissertation addresses the question of why, where and how it is useful, possible and practicable to provide an application with access to lower-level interfaces. It argues that many aspects of  implementation can be devolved safely to untrusted applications and demonstrates this through a prototype which allows control over run-time compilation, object placement within the heap and thread scheduling. The proposed architecture separates these application-specific policy implementations from the application itself. This allows one application to be used with different policies on different systems and also allows naïve or premature optimizations to be removed.

[1]  Matthew L. Seidl,et al.  Segregating heap objects by reference behavior and lifetime , 1998, ASPLOS VIII.

[2]  Godmar Back Patrick Tullmann Leigh Stoller Wilson C. Hsie Lepreau Java Operating Systems : Design and Implementation , 1998 .

[3]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[4]  Jim Waldo Controversy: The Case for Multiple Inheritance in C++ , 1991, Comput. Syst..

[5]  Tim Harris An Extensible Virtual Machine Architecture , 1999 .

[6]  Urs Hölzle,et al.  Removing unnecessary synchronization in Java , 1999, OOPSLA '99.

[7]  Zhenyu Qian,et al.  Toward a provably-correct implementation of the JVM bytecode verifier , 2000, Proceedings DARPA Information Survivability Conference and Exposition. DISCEX'00.

[8]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[9]  Steven M. Hand,et al.  Self-paging in the Nemesis operating system , 1999, OSDI '99.

[10]  Andrew C. Myers,et al.  Parameterized types for Java , 1997, POPL '97.

[11]  R. Kent Dybvig,et al.  Revised5 Report on the Algorithmic Language Scheme , 1986, SIGP.

[12]  Pierre Cointe,et al.  Towards a methodology for explicit composition of metaobjects , 1995, OOPSLA.

[13]  Timothy Roscoe,et al.  The structure of a multi-service operating system , 1995 .

[14]  Robin Milner,et al.  A Calculus of Mobile Processes, II , 1992, Inf. Comput..

[15]  Jong-Deok Choi,et al.  Escape analysis for Java , 1999, OOPSLA '99.

[16]  Sheng Liang,et al.  Dynamic class loading in the Java virtual machine , 1998, OOPSLA '98.

[17]  Nick Benton,et al.  Compiling standard ML to Java bytecodes , 1998, ICFP '98.

[18]  Cristina V. Lopes,et al.  Recent Developments in Aspect , 1998, ECOOP Workshops.

[19]  Cristina V. Lopes,et al.  A study on exception detection and handling using aspect-oriented programming , 2000, Proceedings of the 2000 International Conference on Software Engineering. ICSE 2000 the New Millennium.

[20]  Martín Abadi,et al.  A calculus for cryptographic protocols: the spi calculus , 1997, CCS '97.

[21]  Patrick Lincoln,et al.  Linear logic , 1992, SIGA.

[22]  Darko Stefanovic,et al.  Characterization of object behaviour in Standard ML of New Jersey , 1994, LFP '94.

[23]  Richard Black,et al.  Explicit Network Scheduling , 1994 .

[24]  Urs Hölzle,et al.  Optimizing dynamically-dispatched calls with run-time type feedback , 1994, PLDI '94.

[25]  James R. Bell,et al.  Threaded code , 1973, CACM.

[26]  Samuel P. Midkiff,et al.  Quicksilver: a quasi-static compiler for Java , 2000, OOPSLA '00.

[27]  Mark N. Wegman,et al.  An efficient method of computing static single assignment form , 1989, POPL '89.

[28]  Frank Yellin,et al.  The Java Virtual Machine Specification , 1996 .

[29]  Alex Garthwaite,et al.  Efficient object sampling via weak references , 2000, ISMM '00.

[30]  John Viega,et al.  Automated Delegation is a Viable Alternative to Multiple Inheritance in Class Based Languages , 1998 .

[31]  Bruno Blanchet,et al.  Escape analysis for object-oriented languages: application to Java , 1999, OOPSLA '99.

[32]  S. Tucker Taft Programming the Internet in Ada 95 , 1996, Ada-Europe.

[33]  Paul R. Wilson,et al.  Uniprocessor Garbage Collection Techniques , 1992, IWMM.

[34]  Thorsten von Eicken,et al.  JRes: a resource accounting interface for Java , 1998, OOPSLA '98.

[35]  James Gosling,et al.  Java Intermediate Bytecode , 1995, Intermediate Representations Workshop.

[36]  Bertil Folliot,et al.  A dynamically configurable, multi-language execution platform , 1998, ACM SIGOPS European Workshop.

[37]  Rafael Dueire Lins,et al.  Garbage collection: algorithms for automatic dynamic memory management , 1996 .

[38]  Mike O'Connor,et al.  PicoJava: A Direct Execution Engine For Java Bytecode , 1998, Computer.

[39]  Craig Chambers,et al.  Object-Oriented Multi-Methods in Cecil , 1992, ECOOP.

[40]  Per Bothner Kawa - Compiling Dynamic Languages to Java VM , 1998, USENIX Annual Technical Conference.

[41]  Brian N. Bershad,et al.  Scheduler activations: effective kernel support for the user-level management of parallelism , 1991, TOCS.

[42]  John Michael Robson,et al.  Bounds for Some Functions Concerning Dynamic Storage Allocation , 1974, JACM.

[43]  David Detlefs,et al.  A generational mostly-concurrent garbage collector , 2000, ISMM '00.

[44]  Dan S. Wallach,et al.  Extensible security architectures for Java , 1997, SOSP.

[45]  Michael Franz Run-time code generation as a central system service , 1997, Proceedings. The Sixth Workshop on Hot Topics in Operating Systems (Cat. No.97TB100133).

[46]  Larry L. Peterson,et al.  Scout: a communications-oriented operating system , 1995, Proceedings 5th Workshop on Hot Topics in Operating Systems (HotOS-V).

[47]  Ole Agesen,et al.  Mixed-mode Bytecode Execution , 2000 .

[48]  Stephen N. Freund,et al.  Adding type parameterization to the Java language , 1997, OOPSLA '97.

[49]  Trent Jaeger,et al.  An unconventional proposal: using the x86 architecture as the ubiquitous virtual standard architecture , 1998, EW 8.

[50]  Manoranjan Satpathy,et al.  Rationalized three instruction machine , 1995, IR '95.

[51]  Kathleen Jensen,et al.  Pascal-P Implementation Notes , 1981, Pascal - The Language and its Implementation.

[52]  Bryan Ford,et al.  CPU inheritance scheduling , 1996, OSDI '96.

[53]  Paul Menage RCANE: A Resource Controlled Framework for Active Network Services , 1999, IWAN.

[54]  Harold Abelson,et al.  Revised5 report on the algorithmic language scheme , 1998, SIGP.

[55]  Glenn Krasner,et al.  Smalltalk-80: bits of history, words of advice , 1983 .

[56]  Mitchell Wand,et al.  Continuation-Based Multiprocessing , 1980, High. Order Symb. Comput..

[57]  Robert Harper,et al.  Typing first-class continuations in ML , 1991, POPL '91.

[58]  Martin Odersky,et al.  Pizza into Java: translating theory into practice , 1997, POPL '97.

[59]  Robert Grimm,et al.  Application performance and flexibility on exokernel systems , 1997, SOSP.

[60]  Clark Thomborson,et al.  Manufacturing cheap, resilient, and stealthy opaque constructs , 1998, POPL '98.

[61]  Ian Holyer,et al.  The Brisk Machine: A Simplified STG Machine , 1997, Implementation of Functional Languages.

[62]  Jo A. Lawless,et al.  Understanding CLOS - the common LISP object system , 1991 .

[63]  David Detlefs,et al.  Garbage collection and local variable type-precision and liveness in Java virtual machines , 1998, PLDI.

[64]  Craig Chambers,et al.  Debugging optimized code with dynamic deoptimization , 1992, PLDI '92.

[65]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[66]  Ole Agesen Design and Implementation of Pep, A Java Just-in-Time Translator , 1997, Theory Pract. Object Syst..

[67]  Margo Seltzer,et al.  Issues in Extensible Operating Systems , 1997 .

[68]  Marc Najork,et al.  Performance limitations of the Java core libraries , 2000 .

[69]  Martin Odersky,et al.  Making the future safe for the past: adding genericity to the Java programming language , 1998, OOPSLA '98.

[70]  Bjarne Stroustrup,et al.  C++ : programovací jazyk : The C++ programming language (Orig.) , 1997 .

[71]  Michiaki Tatsubori,et al.  An Extension Mechanism for the Java Language , 1999 .

[72]  Charles E. McDowell,et al.  Unloading Java classes that contain static fields , 1998, SIGP.

[73]  Y. S. Ramakrishna,et al.  An efficient meta-lock for implementing ubiquitous synchronization , 1999, OOPSLA '99.

[74]  Kiem-Phong Vo,et al.  Vmalloc: A General and Efficient Memory Allocator , 1996, Softw. Pract. Exp..

[75]  Michael B. Jones,et al.  CPU reservations and time constraints: efficient, predictable scheduling of independent activities , 1997, SOSP.

[76]  James R. Larus,et al.  Using generational garbage collection to implement cache-conscious data placement , 1998, ISMM '98.

[77]  Dan S. Wallach,et al.  Java security: Web browsers and beyond , 1997 .

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

[79]  Michael Franz,et al.  Slim binaries , 1997, CACM.

[80]  Urs Hölzle,et al.  Adaptive optimization for self: reconciling high performance with exploratory programming , 1994 .

[81]  Craig Chambers,et al.  Making pure object-oriented languages practical , 1991, OOPSLA 1991.

[82]  Simon Dobson,et al.  A first taste of Vanilla , 1998 .

[83]  Deyu Hu,et al.  Implementing Multiple Protection Domains in Java , 1998, USENIX Annual Technical Conference.

[84]  Mauricio J. Serrano,et al.  Thin locks: featherweight synchronization for Java , 1998, PLDI '98.

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

[86]  Suad Alagic,et al.  Parametric polymorphism for Java: a reflective solution , 1998, OOPSLA '98.

[87]  Arie van Deursen,et al.  Domain-specific languages: an annotated bibliography , 2000, SIGP.

[88]  Craig Chambers,et al.  Whole-program optimization of object-oriented languages , 1996 .

[89]  Andre Scedrov,et al.  Linear Logic and Computation: A Survey , 1995 .

[90]  Robert J. Creasy,et al.  The Origin of the VM/370 Time-Sharing System , 1981, IBM J. Res. Dev..

[91]  Emin Gün Sirer,et al.  Distributed virtual machines: a system architecture for network computing , 1998, ACM SIGOPS European Workshop.

[92]  James R. Larus,et al.  Cache-conscious structure layout , 1999, PLDI '99.

[93]  Craig Chambers,et al.  An efficient implementation of SELF a dynamically-typed object-oriented language based on prototypes , 1989, OOPSLA 1989.

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

[95]  Urs Hölzle,et al.  Do Object-Oriented Languages Need Special Hardware Support? , 1995, ECOOP.

[96]  James A. Gosling,et al.  The Java application programming interface , 1996 .

[97]  Jonathan C. Hardwick,et al.  Java as an Intermediate Language , 1996 .

[98]  David E. Culler,et al.  Jaguar: enabling efficient communication and I/O in Java , 2000 .

[99]  Guy L. Steele,et al.  Common Lisp the Language , 1984 .

[100]  Dawson R. Engler,et al.  Exterminate all operating system abstractions , 1995, Proceedings 5th Workshop on Hot Topics in Operating Systems (HotOS-V).

[101]  Benjamin G. Zorn,et al.  Using lifetime predictors to improve memory allocation performance , 1993, PLDI '93.

[102]  Christian Schulte,et al.  An Abstract Machine for Oz , 1995, PLILP.

[103]  Ole Agesen,et al.  Concrete type inference: delivering object-oriented applications , 1995 .

[104]  Ira R. Forman,et al.  Composition of Before/After Metaclasses in SOM , 1994, OOPSLA.

[105]  Jack W. Davidson,et al.  Cint: a RISC interpreter for the C programming language , 1987, PLDI 1987.

[106]  Calton Pu,et al.  A feedback-driven proportion allocator for real-rate scheduling , 1999, OSDI '99.

[107]  Martín Abadi Protection in Programming-Language Translations , 1999, Secure Internet Programming.

[108]  L. Peter Deutsch,et al.  Efficient implementation of the smalltalk-80 system , 1984, POPL.

[109]  Paul Barham,et al.  A fresh approach to file system quality of service , 1997, Proceedings of 7th International Workshop on Network and Operating System Support for Digital Audio and Video (NOSSDAV '97).

[110]  Deyu Hu,et al.  Design and Evaluation of an Extensible Web & Telephony Server based on the J-Kernel , 1998 .

[111]  Paul R. Wilson,et al.  The memory fragmentation problem: solved? , 1998, ISMM '98.

[112]  Brian N. Bershad,et al.  Extensibility safety and performance in the SPIN operating system , 1995, SOSP.

[113]  Michiaki Tatsubori,et al.  Programming Support of Design Patterns with Compile-time Reflection , 2000 .

[114]  Mike Hibler,et al.  Microkernels meet recursive virtual machines , 1996, OSDI '96.

[115]  David Walker,et al.  Typed memory management in a calculus of capabilities , 1999, POPL '99.

[116]  Greg Nelson,et al.  Systems programming in modula-3 , 1991 .

[117]  Robin Fairbairns,et al.  The Design and Implementation of an Operating System to Support Distributed Multimedia Applications , 1996, IEEE J. Sel. Areas Commun..

[118]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[119]  David A. Patterson,et al.  Computer Architecture: A Quantitative Approach , 1969 .

[120]  David W. Barron A Perspective on Pascal , 1981, Pascal - The Language and its Implementation.

[121]  Peter Lee,et al.  Generational stack collection and profile-driven pretenuring , 1998, PLDI.

[122]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[123]  Paul R. Wilson,et al.  Dynamic Storage Allocation: A Survey and Critical Review , 1995, IWMM.

[124]  BlanchetBruno Escape analysis for object-oriented languages , 1999 .

[125]  Dawson R. Engler,et al.  VCODE: a retargetable, extensible, very fast dynamic code generation system , 1996, PLDI '96.

[126]  John H. Reppy,et al.  CML: A Higher-Order Concurrent Language , 1991, PLDI.

[127]  C. A. G. Webster,et al.  Pascal in Education , 1981, Pascal - The Language and its Implementation.

[128]  Erik Ruf,et al.  Effective synchronization removal for Java , 2000, PLDI '00.

[129]  Timothy L. Harris,et al.  Dynamic adaptive pre-tenuring , 2000, ISMM '00.

[130]  David B. MacQueen,et al.  The Definition of Standard ML (Revised) , 1997 .

[131]  Tim Harris Controlling run-time compilation , 1998 .

[132]  Henry G. Baker,et al.  “Use-once” variables and linear objects: storage management, reflection and multi-threading , 1995, SIGP.