3 research outputs found
Improving the Performance of User-level Runtime Systems for Concurrent Applications
Concurrency is an essential part of many modern large-scale software systems. Applications must handle millions of simultaneous requests from millions of connected devices. Handling
such a large number of concurrent requests requires runtime systems that efficiently man-
age concurrency and communication among tasks in an application across multiple cores.
Existing low-level programming techniques provide scalable solutions with low overhead,
but require non-linear control flow. Alternative approaches to concurrent programming,
such as Erlang and Go, support linear control flow by mapping multiple user-level execution
entities across multiple kernel threads (M:N threading). However, these systems provide
comprehensive execution environments that make it difficult to assess the performance
impact of user-level runtimes in isolation.
This thesis presents a nimble M:N user-level threading runtime that closes this con-
ceptual gap and provides a software infrastructure to precisely study the performance
impact of user-level threading. Multiple design alternatives are presented and evaluated
for scheduling, I/O multiplexing, and synchronization components of the runtime. The
performance of the runtime is evaluated in comparison to event-driven software, system-
level threading, and other user-level threading runtimes. An experimental evaluation is
conducted using benchmark programs, as well as the popular Memcached application.
The user-level runtime supports high levels of concurrency without sacrificing application
performance. In addition, the user-level scheduling problem is studied in the context of
an existing actor runtime that maps multiple actors to multiple kernel-level threads. In
particular, two locality-aware work-stealing schedulers are proposed and evaluated. It is
shown that locality-aware scheduling can significantly improve the performance of a class
of applications with a high level of concurrency. In general, the performance and resource
utilization of large-scale concurrent applications depends on the level of concurrency that
can be expressed by the programming model. This fundamental effect is studied by refining
and customizing existing concurrency models