A Lightweight Process Facility Supporting Meta-Level Programming

Abstract This paper presents an implementation method of application-specific lightweight processes (threads). The main feature of this method is that the design of lightweight processes is done by using meta-level programming techniques. In this method, lightweight processes are implemented by using the concepts of microprocesses and virtual processors. A microprocess is an application-level (user-level) lightweight process and it is included in a regular (heavy weight) process. Microprocesses are executed by virtual processors which are provided by the operating system kernel. A virtual processor is an entry of a real processor which is assigned to an application process by the kernel. In this method, a virtual processor is regarded as a meta-lightweight process of user-level lightweight processes. Application programmers can describe the behavior of lightweight processes at the meta-level as well as at the base lightweight process level. In other words, application programmers can control lightweight processes by dealing with virtual processors. Each virtual processor has its own private areas of memory. These areas correspond to the lightweight-process-specific data areas, and they are used to store the identifier of the virtual processor, the variables and the stack of the lightweight process scheduler. At the meta-level, events for state transitions of lightweight processes are recorded, and they are used to tune performance.

[1]  Yasuhiko Yokote,et al.  The Apertos reflective operating system: the concept and its implementation , 1992, OOPSLA '92.

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

[3]  Charles E. McDowell,et al.  Debugging concurrent programs , 1989, ACM Comput. Surv..

[4]  Frank Mueller,et al.  A Library Implementation of POSIX Threads under UNIX , 1993, USENIX Winter.

[5]  Randy B. Osborne,et al.  Speculative computation in multilisp , 1989, LISP and Functional Programming.

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

[7]  Anna R. Karlin,et al.  Empirical studies of competitve spinning for a shared-memory multiprocessor , 1991, SOSP '91.

[8]  Takashi Masuda,et al.  A Relational-Database Machine Based on Functional Programming Concepts , 1986, FJCC.

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

[10]  Susan L. Graham,et al.  Gprof: A call graph execution profiler , 1982, SIGPLAN '82.

[11]  Takashi Masuda,et al.  A thread facility based on user/kernel cooperation in the XERO operating system , 1991, [1991] Proceedings The Fifteenth Annual International Computer Software & Applications Conference.

[12]  Lui Sha,et al.  Priority Inheritance Protocols: An Approach to Real-Time Synchronization , 1990, IEEE Trans. Computers.

[13]  Takashi Masuda,et al.  The software architecture of a parallel processing system for advanced database applications , 1991, [1991] Proceedings. Seventh International Conference on Data Engineering.

[14]  Yasushi Shinjo,et al.  ReSC: a distributed operating system for parallel and distributed applications , 1991, [1991] Proceedings of the First International Conference on Parallel and Distributed Information Systems.

[15]  Yasushi Shinjo,et al.  Harmonizing a distributed operating system with parallel and distributed applications , 1992, Proceedings of the First International Symposium on High-Performance Distributed Computing. (HPDC-1).

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