Aeminium - Freeing Programmers from the Shackles of Sequentiality
Start date: November 1st, 2009. Expected completion date: April 30, 2012
PI: Paulo Marques (FCTUC), Nestor Cataño (Universidade da Madeira), Jonathan Aldrich (CMU), and João Pedro Silva (NOVABASE ACD)
Dual degree Ph.D. student: Sven Stork (Software Engineering/Computer Science) and Filipe Militão (Computer Science)
Teams: Faculdade de Ciências e Tecnologia da Universidade de Coimbra (FCTUC), DME/Universidade da Madeira, Madeira ITI, Carnegie Mellon
Keywords: Software Engineering, Concurrency, Dataflow, Permissions, Verifications
Current programming systems shackle developers to a sequential coding paradigm. This paradigm hampers developers from taking advantage of emerging large‐scale multicore hardware. We propose a platform which builds in concurrency by default: instead of sequencing code, programmers express dependency information, which is used by a compile‐time checker to verify correctness conditions, and by the libraries and runtime system to enable concurrent execution. As a result, developers can write parallel code in a natural style and have confidence in its correctness and performance.
The Aeminium Project – Freeing Programmers from the Shackles of Sequentiality – aims at addressing this fundamental problem: how to provide mainstream programmers with a practical framework for developing massively concurrent applications. In particular, we propose to create a platform which builds in concurrency by default: instead of sequencing code, programmers express dependency information, which are used by a compile time checker to verify correctness conditions, and by the libraries and runtime system to enable concurrent execution. As a result, developers can write parallel code in a natural style and have confidence in its correctness and performance. We explicitly target modern mainstream object oriented programming environments, like Java and .NET, used by common programmers in the majority of common application domains.
The research will be focused on the following ideas:
- A language where sequencing between commands is not expressed directly by the programmer (i.e., sequentiality by default), but instead is specified indirectly through dependencies between commands. These could be ordinary dataflow dependencies, or they could be dependencies on a side effect of some other command. We track these dependencies through the type system at compile time, and through libraries and the runtime system at run time.
- A runtime platform which has concurrent libraries and data‐structures built‐in and turnedon by default. Even if programmers write commands with sequential dependencies, they can by default, obtain performance improvements from parallel library code when hardware resources are available (e.g. extra cores). The runtime system leverages the dependency information to optimize concurrent execution, making tradeoffs between task granularity and parallelism among tasks.
- A lightweight static verification system checks at compile time that no dependencies have been missed by the programmer, ensuring a lack of race conditions and other common concurrency errors. The verification tool will leverage the PIs’ ongoing work on verifying the interface protocols of libraries and frameworks.