Synthesis: an efficient implementation of fundamental operating system services

This dissertation shows that operating systems can provide fundamental services an order of magnitude more efficiently than traditional implementations. It describes the implementation of a new operating system kernel, Synthesis, that achieves this level of performance. The Synthesis kernel combines several new techniques to provide high performance without sacrificing the expressive power or security of the system. The new ideas include: (1) Run-time code synthesis--a systematic way of creating executable machine code at runtime to optimize frequently-used kernel routines--queues, buffers, context switchers, interrupt handlers, and system call dispatchers--for specific situations, greatly reducing their execution time. (2) Fine-grain scheduling--a new process-scheduling technique based on the idea of feedback that performs frequent scheduling actions and policy adjustments (at sub-millisecond intervals) resulting in an adaptive, self-tuning system that can support real-time data streams. (3) Lock-free optimistic synchronization is shown to be a practical, efficient alternative to lock-based synchronization methods for the implementation of multiprocessor operating system kernels. (4) An extensible kernel design that provides for simple expansion to support new kernel services and hardware devices while allowing a tight coupling between the kernel and the applications, blurring the distinction between user and kernel services. The result is a significant performance improvement over traditional operating system implementations in addition to providing new services.

[1]  Susan J. Eggers,et al.  A case for runtime code generation , 1993 .

[2]  Brian N. Bershad,et al.  An Open Environment for Building Parallel Programming Systems , 1988, PPOPP/PPEALS.

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

[4]  J.A. Stankovic,et al.  Misconceptions about real-time computing: a serious problem for next-generation systems , 1988, Computer.

[5]  William J. Bolosky,et al.  Mach: A New Kernel Foundation for UNIX Development , 1986, USENIX Summer.

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

[7]  Neil D. Jones,et al.  Mix: A self-applicable partial evaluator for experiments in compiler generation , 1989, LISP Symb. Comput..

[8]  Dennis M. Ritchie,et al.  A stream input-output system , 1990 .

[9]  Mary K. Vernon,et al.  Comparison of hardware and software cache coherence schemes , 1991, ISCA '91.

[10]  Michael Stonebraker,et al.  Operating system support for database management , 1981, CACM.

[11]  Brian N. Bershad,et al.  Using continuations to implement thread management and communication in operating systems , 1991, SOSP '91.

[12]  Anant Agarwal,et al.  Evaluating the performance of software cache coherence , 1989, ASPLOS III.

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

[14]  Carl H. Hauser,et al.  The portable common runtime approach to interoperability , 1989, SOSP '89.

[15]  J. Feder The UNIX system: The evolution of UNIX system performance , 1984, AT&T Bell Laboratories Technical Journal.

[16]  Andrew P. Black,et al.  Object structure in the Emerald system , 1986, OOPSLA 1986.

[17]  Kwei-Jay Lin,et al.  A priority ceiling protocol for multiple-instance resources , 1991, [1991] Proceedings Twelfth Real-Time Systems Symposium.

[18]  Harvey M. Deitel,et al.  An introduction to operating systems , 1984 .

[19]  K. Arvind,et al.  Probabilistic Clock Synchronization in Distributed Systems , 1994, IEEE Trans. Parallel Distributed Syst..

[20]  Maurice Herlihy,et al.  Wait-free synchronization , 1991, TOPL.

[21]  Calton Pu,et al.  The Synthesis Kernel , 1988, Comput. Syst..

[22]  John K. Ousterhout,et al.  Why Aren't Operating Systems Getting Faster As Fast as Hardware? , 1990, USENIX Summer.

[23]  David L. Black Scheduling support for concurrency and parallelism in the Mach operating system , 1990, Computer.

[24]  David R. Cheriton An experiment using registers for fast message-based interprocess communication , 1984, OPSR.

[25]  Evangelos P. Markatos,et al.  First-class user-level threads , 1991, SOSP '91.

[26]  Calton Pu,et al.  Threads and input/output in the synthesis kernal , 1989, SOSP '89.

[27]  Peter Wegner,et al.  Dimensions of object-based language design , 1987, OOPSLA '87.

[28]  Abraham Silberschatz,et al.  4.2BSD and 4.3BSD as examples of the UNIX system , 1985, CSUR.