First-class user-level threads

Brian D. Marsh, Michael L. Scott, Thomas J. LeBlanc, Evangelos P. Markatos

Research output: Chapter in Book/Report/Conference proceedingConference contribution

87 Citations (Scopus)

Abstract

It is often desirable, for reasons of clarity, portability, and efficiency, to write parallel programs in which the number of processes is independent of the number of available processors. Several modern operating systems support more than one process in an address space, but the overhead of creating and synchronizing kernel processes can be high. Many runtime environments implement lightweight processes (threads) in user space, but this approach usually results in second-class status for threads, making it difficult or impossible to perform scheduling operations at appropriate times (e.g. when the current thread blocks in the kernel). In addition, a lack of common assumptions may also make it difficult for parallel programs or library routines that use dissimilar thread packages to communicate with each other, or to synchronize access to shared data.We describe a set of kernel mechanisms and conventions designed to accord first-class status to user-level threads, allowing them to be used in any reasonable way that traditional kernel-provided processes can be used, while leaving the details of their implementation to user-level code. The key features of our approach are (1) shared memory for asynchronous communication between the kernel and the user, (2) software interrupts for events that might require action on the part of a user-level scheduler, and (3) a scheduler interface convention that facilitates interactions in user space between dissimilar kinds of threads. We have incorporated these mechanisms in the Psyche parallel operating system, and have used them to implement several different kinds of user-level threads. We argue for our approach in terms of both flexibility and performance.

Original languageEnglish (US)
Title of host publicationProceedings of the 13th ACM Symposium on Operating Systems Principles, SOSP 1991
Pages110-121
Number of pages12
DOIs
StatePublished - 1991
Externally publishedYes
Event13th ACM Symposium on Operating Systems Principles, SOSP 1991 - Pacific Grove, CA, United States
Duration: Oct 13 1991Oct 16 1991

Other

Other13th ACM Symposium on Operating Systems Principles, SOSP 1991
CountryUnited States
CityPacific Grove, CA
Period10/13/9110/16/91

Fingerprint

Scheduling
Data storage equipment
Communication

ASJC Scopus subject areas

  • Software

Cite this

Marsh, B. D., Scott, M. L., LeBlanc, T. J., & Markatos, E. P. (1991). First-class user-level threads. In Proceedings of the 13th ACM Symposium on Operating Systems Principles, SOSP 1991 (pp. 110-121) https://doi.org/10.1145/121132.344329

First-class user-level threads. / Marsh, Brian D.; Scott, Michael L.; LeBlanc, Thomas J.; Markatos, Evangelos P.

Proceedings of the 13th ACM Symposium on Operating Systems Principles, SOSP 1991. 1991. p. 110-121.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Marsh, BD, Scott, ML, LeBlanc, TJ & Markatos, EP 1991, First-class user-level threads. in Proceedings of the 13th ACM Symposium on Operating Systems Principles, SOSP 1991. pp. 110-121, 13th ACM Symposium on Operating Systems Principles, SOSP 1991, Pacific Grove, CA, United States, 10/13/91. https://doi.org/10.1145/121132.344329
Marsh BD, Scott ML, LeBlanc TJ, Markatos EP. First-class user-level threads. In Proceedings of the 13th ACM Symposium on Operating Systems Principles, SOSP 1991. 1991. p. 110-121 https://doi.org/10.1145/121132.344329
Marsh, Brian D. ; Scott, Michael L. ; LeBlanc, Thomas J. ; Markatos, Evangelos P. / First-class user-level threads. Proceedings of the 13th ACM Symposium on Operating Systems Principles, SOSP 1991. 1991. pp. 110-121
@inproceedings{35d34646a8154df283269aa13a8e6879,
title = "First-class user-level threads",
abstract = "It is often desirable, for reasons of clarity, portability, and efficiency, to write parallel programs in which the number of processes is independent of the number of available processors. Several modern operating systems support more than one process in an address space, but the overhead of creating and synchronizing kernel processes can be high. Many runtime environments implement lightweight processes (threads) in user space, but this approach usually results in second-class status for threads, making it difficult or impossible to perform scheduling operations at appropriate times (e.g. when the current thread blocks in the kernel). In addition, a lack of common assumptions may also make it difficult for parallel programs or library routines that use dissimilar thread packages to communicate with each other, or to synchronize access to shared data.We describe a set of kernel mechanisms and conventions designed to accord first-class status to user-level threads, allowing them to be used in any reasonable way that traditional kernel-provided processes can be used, while leaving the details of their implementation to user-level code. The key features of our approach are (1) shared memory for asynchronous communication between the kernel and the user, (2) software interrupts for events that might require action on the part of a user-level scheduler, and (3) a scheduler interface convention that facilitates interactions in user space between dissimilar kinds of threads. We have incorporated these mechanisms in the Psyche parallel operating system, and have used them to implement several different kinds of user-level threads. We argue for our approach in terms of both flexibility and performance.",
author = "Marsh, {Brian D.} and Scott, {Michael L.} and LeBlanc, {Thomas J.} and Markatos, {Evangelos P.}",
year = "1991",
doi = "10.1145/121132.344329",
language = "English (US)",
isbn = "0897914473",
pages = "110--121",
booktitle = "Proceedings of the 13th ACM Symposium on Operating Systems Principles, SOSP 1991",

}

TY - GEN

T1 - First-class user-level threads

AU - Marsh, Brian D.

AU - Scott, Michael L.

AU - LeBlanc, Thomas J.

AU - Markatos, Evangelos P.

PY - 1991

Y1 - 1991

N2 - It is often desirable, for reasons of clarity, portability, and efficiency, to write parallel programs in which the number of processes is independent of the number of available processors. Several modern operating systems support more than one process in an address space, but the overhead of creating and synchronizing kernel processes can be high. Many runtime environments implement lightweight processes (threads) in user space, but this approach usually results in second-class status for threads, making it difficult or impossible to perform scheduling operations at appropriate times (e.g. when the current thread blocks in the kernel). In addition, a lack of common assumptions may also make it difficult for parallel programs or library routines that use dissimilar thread packages to communicate with each other, or to synchronize access to shared data.We describe a set of kernel mechanisms and conventions designed to accord first-class status to user-level threads, allowing them to be used in any reasonable way that traditional kernel-provided processes can be used, while leaving the details of their implementation to user-level code. The key features of our approach are (1) shared memory for asynchronous communication between the kernel and the user, (2) software interrupts for events that might require action on the part of a user-level scheduler, and (3) a scheduler interface convention that facilitates interactions in user space between dissimilar kinds of threads. We have incorporated these mechanisms in the Psyche parallel operating system, and have used them to implement several different kinds of user-level threads. We argue for our approach in terms of both flexibility and performance.

AB - It is often desirable, for reasons of clarity, portability, and efficiency, to write parallel programs in which the number of processes is independent of the number of available processors. Several modern operating systems support more than one process in an address space, but the overhead of creating and synchronizing kernel processes can be high. Many runtime environments implement lightweight processes (threads) in user space, but this approach usually results in second-class status for threads, making it difficult or impossible to perform scheduling operations at appropriate times (e.g. when the current thread blocks in the kernel). In addition, a lack of common assumptions may also make it difficult for parallel programs or library routines that use dissimilar thread packages to communicate with each other, or to synchronize access to shared data.We describe a set of kernel mechanisms and conventions designed to accord first-class status to user-level threads, allowing them to be used in any reasonable way that traditional kernel-provided processes can be used, while leaving the details of their implementation to user-level code. The key features of our approach are (1) shared memory for asynchronous communication between the kernel and the user, (2) software interrupts for events that might require action on the part of a user-level scheduler, and (3) a scheduler interface convention that facilitates interactions in user space between dissimilar kinds of threads. We have incorporated these mechanisms in the Psyche parallel operating system, and have used them to implement several different kinds of user-level threads. We argue for our approach in terms of both flexibility and performance.

UR - http://www.scopus.com/inward/record.url?scp=0011611820&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=0011611820&partnerID=8YFLogxK

U2 - 10.1145/121132.344329

DO - 10.1145/121132.344329

M3 - Conference contribution

AN - SCOPUS:0011611820

SN - 0897914473

SN - 9780897914475

SP - 110

EP - 121

BT - Proceedings of the 13th ACM Symposium on Operating Systems Principles, SOSP 1991

ER -