(This is the PhD proposal that I submitted originally. It bears very little resemblance to what I actually ended up doing — I did do some work on RMoX initially, but I wound up concentrating on design patterns for process-oriented programming, so RMoX was just one of several case studies.)
Parallelism is a key programming technique that can be usefully exploited in a wide variety of applications. Today, programmers are increasingly turning to parallelism as a way of overcoming the limitations of mainstream sequential languages. However, most popular environments provide little explicit support for parallelism, leading to the common view that "concurrency is hard".
The occam programming language is well suited to the development of parallel programs: it provides excellent native support for concurrency, based on the compositional semantics of CSP (Communicating Sequential Processes), and provides a natural way of expressing parallelism in highly-scalable applications. Additionally, the occam compiler's rigorous correctness checking prevents many types of common programmer error endemic to parallel programming in other languages.
Ongoing research at the University of Kent has produced a new variant of this language, occam-pi, removing many of occam's original limitations and introducing features found in other modern programming languages, including data, process and channel mobility (a key idea in the pi-calculus).
A thriving area of research is that of highly concurrent operating systems. Operating systems are the core software components of all computing platforms, from small embedded systems in electronic devices to large distributed systems spanning global networks.
Most current operating systems follow traditional sequential designs, largely unchanged since the 1960s. Consequences of this include poor scalability, difficulty in distributing problems among multiple systems, and convoluted internal logic where resources must be shared between concurrent activities. Ever-increasing requirements for computing power are driving forward the development of parallel hardware; multi-processor systems are becoming increasingly common. Systems software designed explicitly for parallelism is required to make optimal use of such hardware.
The occam-pi language's parallel and low-level programming features make it ideal for the development of highly-parallel operating systems. To date, a fairly basic but functional demonstrator of a concurrent operating system written using occam-pi exists: "RMoX".
This research project aims to investigate further the use of concurrency within operating systems: in particular, filesystems, network stacks and process management for highly-concurrent systems.
Filesystems can exploit concurrency and distribution on several levels. Lack of internal concurrency has traditionally caused performance limitations on conventional filesystems. Operating systems for distributed clusters of machines have additional requirements for performance and fault tolerance while maintaining data integrity; such filesystems are of increasing interest to operators of large network services as means of reliably processing vast quantities of data.
While network stacks are required to deal with many parallel streams of data, they are usually written with sequential logic. The application of parallel-programming techniques has the potential to increase performance, reliability, maintainability and security of network software. Reliable parallel applications may also require features not offered by existing network protocols and software.
Current occam-pi systems do not fully exploit the potential of hardware parallelism. Support for running concurrent programs on multiple-processor and distributed systems will make it possible to address much larger problems at lower costs using modern commodity hardware.
This research will help develop RMoX from a prototype into a usable operating system providing unprecedented levels of performance, security and reliability.