Canada Spends Logo

Explore our Budget 2026 analysis

Grant: Discovery Grants Program - Individual

University of Waterloo

$20,000.00

High-Performance User-Level Threading

FY 2018-19

Summary
The purpose of this research program is to examine the abstract notion of threads and the mechanisms for their interaction in a programming language. The goal is to provide programmers with the ability to choose the amount of concurrency that best fits the problem, while still achieving good performance. The mechanism to accomplish this goal is user-level threading, which can scale to 10,000-100,000 threads, and can work with threading models in any programming language. The primary benefit from large numbers of threads is over-partitioning into small work-units to facilitate load balancing by the runtime. The secondary benefit is simpler concurrent program-construction using thread objects, leveraging normal object-construction in object-oriented programming. After experimenting with the user-level M:N threading model 15 years ago, the UNIX community adopted the 1:1 threading model. Hence, instead of M user threads multiplexing across N OS kernel-threads (M>>N), each user-level thread is bound to one kernel thread. However, 1:1 threading systems are beginning to saturate with increased processors and struggle to support concurrency approaches with large numbers of threads.*As a result, the notion of user-level M:N threading is being revisited with the expectation of untapped performance potential from low-cost: thread creation/deletion, context switching, synchronization, mutual exclusion, and preemption. The results are reinvigorating program-language and OS interaction with respect to creating and managing large numbers of threads in an application. For example, the languages Erlang, Haskell, and the new Go language from Google adopt the M:N threading model, providing simple mechanisms to create, and manage large numbers of user-level threads. Unfortunately, the 1:1 threading-model at the kernel level significantly constrains the M:N threading-model through restrictions at the kernel/application boundary. The objective of this research program is to reexamine the major problem areas of M:N threading, e.g., scheduling, blocking, garbage collection, and preemption, to see if new solutions can be engineered. Current M:N systems do not handle some of these problems, and hence are fragile or restrictive, or ignore them by adopting a closed environment (no outside interaction). While user-level threading has been worked on extensively, it still remains a challenging problem with many open issues, e.g., as the kernel is unaware of user threads, conflicting interactions occur.*The focus of this research program is leveraging existing mechanisms as much as possible to generate proof-of-concepts for user-level threading. The scientific approach is extending the runtime for C++ and Go (and possibly Java) to identify fundamental user-level threading problems and test different solutions. Next is building performance experiments to compare approaches. Finally, extensive analysis of the results is required to understand where time is being lost or gained. Success will be measured by demonstrating a significant performance gain in a few key areas using M:N threading versus 1:1 threading (e.g., thread-per-connection web-server). The primary novelty and expected significance of the work is in programming-language runtime-support with respect to high-performance scheduling using available OS mechanisms. The secondary significance is to work with OS researchers and hardware designers to explore a few approaches for high-performance interactions across the application/OS boundary. The results directly re-address the question of whether M:N threading is a viable direction for future programming-language and OS development. Answering this question is crucial to the development direction of both these areas over the next 5 years.
Program
Discovery Grants Program - Individual
Location
Ontario, Canada
Recipient Type
Academia
Type
Grant
Source
NSERC's Awards Data

As published

Application id
RGPIN-2014-04873
Name nom
Buhr, Peter
Department département
Computer Science, David R. Cheriton School of - Computer Science, David R. Cheri
Organization id
33
Institution établissement
University of Waterloo
Province en
Ontario
Province fr
Ontario
Country en
CANADA
Country fr
CANADA
Fiscal year exercice financier
2018
Competition year année de concours
2014
Award amount
20000
Program id
RGPIN
Program name en
Discovery Grants Program - Individual
Program name fr
Programme de subventions à la découverte - individuelles
Group en
Discovery grants programs
Group fr
Programmes de subventions à la découverte
Committee code
1507
Committee name en
Computer Science
Committee name fr
Sciences informatiques
Area of application code
801
Area of application group en
Information and communication services
Area of application group fr
Services d'information et de télécommunications
Area of application en
Computer software
Area of application fr
Logiciel
Research subject code
2720
Research subject group en
Information technology
Research subject group fr
Technologie de l'information
Research subject en
Computer systems software
Research subject fr
Logiciel de systèmes informatiques
Partie
5
Nb partie
5
Application title
High-Performance User-Level Threading
Keyword
NSERC
Application summary
The purpose of this research program is to examine the abstract notion of threads and the mechanisms for their interaction in a programming language. The goal is to provide programmers with the ability to choose the amount of concurrency that best fits the problem, while still achieving good performance. The mechanism to accomplish this goal is user-level threading, which can scale to 10,000-100,000 threads, and can work with threading models in any programming language. The primary benefit from large numbers of threads is over-partitioning into small work-units to facilitate load balancing by the runtime. The secondary benefit is simpler concurrent program-construction using thread objects, leveraging normal object-construction in object-oriented programming. After experimenting with the user-level M:N threading model 15 years ago, the UNIX community adopted the 1:1 threading model. Hence, instead of M user threads multiplexing across N OS kernel-threads (M>>N), each user-level thread is bound to one kernel thread. However, 1:1 threading systems are beginning to saturate with increased processors and struggle to support concurrency approaches with large numbers of threads.*As a result, the notion of user-level M:N threading is being revisited with the expectation of untapped performance potential from low-cost: thread creation/deletion, context switching, synchronization, mutual exclusion, and preemption. The results are reinvigorating program-language and OS interaction with respect to creating and managing large numbers of threads in an application. For example, the languages Erlang, Haskell, and the new Go language from Google adopt the M:N threading model, providing simple mechanisms to create, and manage large numbers of user-level threads. Unfortunately, the 1:1 threading-model at the kernel level significantly constrains the M:N threading-model through restrictions at the kernel/application boundary. The objective of this research program is to reexamine the major problem areas of M:N threading, e.g., scheduling, blocking, garbage collection, and preemption, to see if new solutions can be engineered. Current M:N systems do not handle some of these problems, and hence are fragile or restrictive, or ignore them by adopting a closed environment (no outside interaction). While user-level threading has been worked on extensively, it still remains a challenging problem with many open issues, e.g., as the kernel is unaware of user threads, conflicting interactions occur.*The focus of this research program is leveraging existing mechanisms as much as possible to generate proof-of-concepts for user-level threading. The scientific approach is extending the runtime for C++ and Go (and possibly Java) to identify fundamental user-level threading problems and test different solutions. Next is building performance experiments to compare approaches. Finally, extensive analysis of the results is required to understand where time is being lost or gained. Success will be measured by demonstrating a significant performance gain in a few key areas using M:N threading versus 1:1 threading (e.g., thread-per-connection web-server). The primary novelty and expected significance of the work is in programming-language runtime-support with respect to high-performance scheduling using available OS mechanisms. The secondary significance is to work with OS researchers and hardware designers to explore a few approaches for high-performance interactions across the application/OS boundary. The results directly re-address the question of whether M:N threading is a viable direction for future programming-language and OS development. Answering this question is crucial to the development direction of both these areas over the next 5 years.