Roger Needham lecture 2017

Many-core programming: How to go really fast without crashing

Monday 20 November 2017
The Royal Society, London

Software must be reliable, working well enough, enough of the time. Software also needs to be efficient if it is to be useful. In some domains - robotic surgery, or self-driving cars, to name two examples - software needs to be both very efficient and very reliable. Due to the wide range of devices on which software now runs, software portability is also highly desirable.

Unfortunately, these three requirements - reliability, efficiency and portability - are often at odds with each other. This is particularly the case in the world of "many-core" architectures, which use large numbers of processing elements to compute results in a highly parallel fashion. Many-core architectures can be used to accelerate software so that it runs very efficiently, and are present in every modern desktop, laptop, tablet and smartphone.

Many-core programming languages are usually low-level, providing the "close-to-the-metal" capabilities needed for high performance. Unfortunately, this makes it difficult to write portable many-core software, and the difficulty of low-level programming means that it is easy to accidentally introduce subtle errors into an application.

This has led to an interest in higher-level languages that offer better portability and reduce the scope for programmer errors, but which must be "compiled" down to lower-level forms. While appealing, such languages lead to layers of abstraction, and reliability suffers due to errors in translating code across abstraction layers.

My lecture will focus on the challenges of "going really fast without crashing" in the context of many-core systems. I will use practical examples to demonstrate the main problems associated with programming many-core systems. I will then showcase three different areas where my research group and I have contributed to getting a handle on these problems: (1) static analysis for low-level many-core code, (2) a high-level programming model for portable programming, and (3) a "fuzzing" technique to identify bugs in many-core compilers.


Alastair Donaldson is a Reader and EPSRC Early Career Fellow in the Department of Computing, Imperial College London, where he leads the Multicore Programming Group.

He has published more than 70 peer-reviewed papers on programming languages, formal verification, software testing and parallel programming, and leads the GPUVerify project on automatic verification of GPU kernels - a collaboration with Microsoft Research - and the GLFuzz project on automated testing for graphics shader compilers.

Alastair coordinated the FP7 project CARP: Correct and Efficient Accelerator Programming, which completed successfully in 2015. Before joining Imperial, Alastair was a Visiting Researcher at Microsoft Research Redmond, an EPSRC Postdoctoral Research Fellow at the University of Oxford and a Research Engineer at Codeplay Software Ltd. He holds a PhD from the University of Glasgow.


Registration: 18.00-18.30
Introduction and presentation of awards: 18.30-19.00
Lecture: 19.00-19.45
Q&A: 19.45-20.30
Optional buffet / drinks reception: 20.30-21.30

Speaker: Dr Alastair Donaldson

Alastair Donaldson
Book now