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

Schedulability analysis of timed CSP models using the PAT model checker

Timed CSP can be used to model and analyse real-time and concurrent behaviour of embedded control systems. Practical CSP implementations combine the CSP model of a real-time control system with prioritized scheduling to achieve efficient and orderly use of limited resources. Schedulability analysis of a timed CSP model of a system with respect to a scheduling scheme and a particular execution platform is important to ensure that the system design satisfies its timing requirements. In this paper, we propose a framework to analyse schedulability of CSP-based designs for non-preemptive fixed-priority multiprocessor scheduling. The framework is based on the PAT model checker and the analysis is done with dense-time model checking on timed CSP models. We also provide a schedulability analysis workflow to construct and analyse, using the proposed framework, a timed CSP model with scheduling from an initial untimed CSP model without scheduling. We demonstrate our schedulability analysis workflow on a case study of control software design for a mobile robot. The proposed approach provides non-pessimistic schedulability results

The ProcessJ C++ Runtime System and Code Generator

ProcessJ is a modern Process-Oriented language that builds on previous work from other languages like occam and occam-pi. However, the only readily-available runtime system is built on top of the Java Virtual Machine (JVM). This is not a choice made intentionally, but simply out of a lack of other implementations -- until now. This thesis introduces the new C++-based runtime system for ProcessJ, coupled with a new C++ code generator for the ProcessJ compiler. This thesis later examines the implementation details of the runtime system, including the components that make it up. We also examine the ability to cooperatively schedule many processes within the runtime environment, inside a separate scheduling system built on top of traditional operating system threading, rather than simply mapping processes one-to-one with threads. We later exemplify some of the cooperatively-schedulable code generated by the compiler, giving a complete rundown of the constituents and their various design choices. Lastly, we show the results of several tests that demonstrate the performance benefits of a bespoke C++-based runtime system, and discuss the future work and optimizations of this system

C++CSP2: A Many-to-Many Threading Model for Multicore Architectures

The advent of mass-market multicore processors provides exciting new opportunities for parallelism on the desktop. The original C++CSP – a library providing concurrency in C++ – used only user-threads, which would have prevented it taking advantage of this parallelism. This paper details the development of C++CSP2, which has been built around a many-to-many threading model that mixes user-threads and kernel-threads, providing maximum flexibility in taking advantage of multicore and multi-processormachines. New and existing algorithms are described for dealing with the run-queue and implementing channels, barriers and mutexes. The latter two are benchmarked to motivate the choice of algorithm. Most of these algorithms are based on the use of atomic instructions, to gain maximal speed and efficiency. Other issues related to the new design and related to implementing concurrency in a language like C++ that has no direct support for it, are also described. The C++CSP2 library will be publicly released under the LGPL before CPA 2007

The JVMCSP Runtime and Code Generator for ProcessJ in Java

The modern day advancements in multi-core technologies require programmers to use the right tools and languages to fully harness their potentials. On that front, our endeavor lies in developing a new multipro- cessing programming language. Concurrent or parallel programs can be hard to get right because of locks, monitors, mutexes, etc. One solution is using a CSP based process-oriented language. Process-oriented programming alleviates many of the problems found in thread and lock programming by proper encapsu- lation of data, explicit synchronous message passing, and the ability to verify code to be free of deadlocks and livelocks by using tools like FDR. Therefore, we have developed a new language called ProcessJ (CSP semantics and Java-like syntax) as a way to modernize languages like occam/occam-π which are outdated and only run on certain Linux distributions. ProcessJ is a multi-backend language with a compiler written in Java; and in this thesis, we focus on the JVM backend, which we call the JVMCSP; in particular, we consider code generation, the necessary runtime classes to support concurrency constructs on the JVM, and a simple cooperative non-preemptive scheduler. We also show how to translate ProcessJ source into Java source that makes use of the runtime classes that we have developed