Heterogeneous multi-core processors are key to complex computational problems such as real-time medical imaging, financial analysis and high-definition video, because of the increased processing power they make available. The reliability and probity of such applications is of critical importance, yet heterogeneous multi-core processors are notoriously difficult to program correctly. There is a need for analysis and verification techniques to help detect and fix errors early in the design of multi-core software. The development of such techniques is the aim of the proposed Fellowship research.The research will involve extending the capabilities of existing theoretical computer science techniques based on typechecking and model checking. Typechecking is a commonly used lightweight method for eliminating errors in computer programs: a basic typechecker will reject an invalid expression such as Hello + 1. More complex typechecking, based on session types , can allow a protocol between two parties in a system to be automatically checked. One part of the Fellowship research will involve extending the notion of session types to be applicable to heterogeneous multi-core processors. New typechecking methods will also be developed to help programmers deal with complex issues arising from the management of separate memory spaces in multi-core systems.Model checking is a technique for verifying hardware and software systems which attempts to find system bugs by checking an abstract model of the system. Model checking is less widely used than typechecking, but model checking techniques have recently been incorporated in software products from major vendors such as Microsoft. A major part of the fellowship research will involve developing advanced model checking techniques to help find errors associated with the dynamic behaviour of software for heterogeneous multi-core processors.Part of the research will involve developing a set of open-source tools based on the novel formal analysis techniques. Experience has shown that developers interested in multi-core programming are reluctant to adopt new languages and formalisms, and will only consider new techniques if they are easy and intuitive to use, and can be integrated into an existing development tool-chain. To increase the potential for eventual adoption by industry, the new techniques developed during the Fellowship research will involve regular input and advice from Codeplay Software Ltd., a UK based company specialising in development tools for multi-core processors.

Heterogeneous multi-core processors are key to complex computational problems such as real-time medical imaging, financial analysis and high-definition video, because of the increased processing power they make available. The reliability and probity of such applications is of critical importance, yet heterogeneous multi-core processors are notoriously difficult to program correctly. There is a need for analysis and verification techniques to help detect and fix errors early in the design of multi-core software. The development of such techniques is the aim of the proposed Fellowship research.The research will involve extending the capabilities of existing theoretical computer science techniques based on typechecking and model checking. Typechecking is a commonly used lightweight method for eliminating errors in computer programs: a basic typechecker will reject an invalid expression such as Hello + 1. More complex typechecking, based on session types , can allow a protocol between two parties in a system to be automatically checked. One part of the Fellowship research will involve extending the notion of session types to be applicable to heterogeneous multi-core processors. New typechecking methods will also be developed to help programmers deal with complex issues arising from the management of separate memory spaces in multi-core systems.Model checking is a technique for verifying hardware and software systems which attempts to find system bugs by checking an abstract model of the system. Model checking is less widely used than typechecking, but model checking techniques have recently been incorporated in software products from major vendors such as Microsoft. A major part of the fellowship research will involve developing advanced model checking techniques to help find errors associated with the dynamic behaviour of software for heterogeneous multi-core processors.Part of the research will involve developing a set of open-source tools based on the novel formal analysis techniques. Experience has shown that developers interested in multi-core programming are reluctant to adopt new languages and formalisms, and will only consider new techniques if they are easy and intuitive to use, and can be integrated into an existing development tool-chain. To increase the potential for eventual adoption by industry, the new techniques developed during the Fellowship research will involve regular input and advice from Codeplay Software Ltd., a UK based company specialising in development tools for multi-core processors.

Computers have revolutionised our lives, from mobile phones that exceed the computational power of early supercomputers by orders of magnitudes, to today's supercomputers that help discovery of new drugs to cure serious diseases and to design more energy efficient vehicles and buildings. All this progress has been made possible by continuously increasing computational power. However, there are two threats to this trend. First, harnessing this resource has become increasingly difficult. Imagine a car that provides direct control of fuel mix, 20 gears and adjustable valve timing. This car will provide excellent performance, but requires a driver with an engineering degree to make the optimal adjustments. Second, similar to improved car fuel efficiency, there is increasing demand for improved computational energy efficiency. We cannot attach larger batteries to a mobile phone, or build a nuclear power station next to each data centre. While there are ongoing discoveries that improve efficiency, these solutions intensify the first problem: they increase the difficulty. For a solution to be truly practical it needs to be usable by non-experts! This project aims to address this in case of Approximate Computing -- a recently proposed technology aiming to increase energy efficiency by orders of magnitude. The basic insight of approximate computing is that, traditionally, computers always provide a precise and exact solution instead of a good enough solution. This obsession with precision is very energy wasteful. Imagine that you quickly look into your wallet to check how much cash you carry, you wonder if it is a 1-2 GBP, about 20 GBP or more than 50 GBP. One usually does not really care if it is 17.42 GBP or 17.43 GBP. In such a situation, it would be a waste of time to count the cash precisely. Research has shown that a vast body of problems can take advantage of this kind of imprecision. This research project aims to make approximate computing technology available to non-expert programmers. In particular, the main obstacle for widespread adaptation is that current state of the art in approximate computing burdens the application programmer with providing a suitable approximate alternative. This is comparable to burdening the driver of a car with sophisticated mechanical tasks such as changing a timing belt. The premise of this project is that it is possible to derive an approximation automatically and that this process should be integrated with the tool that every programmer already uses -- the compiler.

The focus of this proposal is on the detection and survival of wrong code compiler defects, which we argue present a cyber-security threat that has been largely ignored to date. First, incorrectly compiled code can introduce exploitable vulnerabilities that are not visible at the source code level, and thus cannot be detected by source-level static analysers. Second, incorrectly compiled code can undermine the reliability of the application, which can have dramatic repercussions in the context of safety-critical systems. Third, wrong code compiler defects can also be the target of some of the most insidious security attacks. A crafty attacker posing as an open source developer can introduce a compiler-bug-based backdoor into a security-critical application by adding a patch that looks perfectly innocent but which, when compiled with a certain compiler, yields binary code that allows the attacker to compromise the software. In this project, we aim to explore automated techniques that can detect and prevent such problems. In particular, we plan to investigate techniques for automatically finding compiler-induced vulnerabilities in real software, approaches for understanding the extent to which an attacker could maliciously modify an application to create a compiler-induced vulnerability, and methods for preventing against such vulnerabilities at runtime.

Computing pervades our lives, impacting our health, work, entertainment and social interaction. Over recent years, the technology inside the devices providing these services has undergone a radical change: where once, processing was undertaken by relatively homogeneous "sequential" devices, in which essentially one thing happened at a time, the new systems compose a range of specialized devices, some targeting specific problem sub domains, and almost all exhibiting considerable "parallelism", where many things can happen at the same time. This is true on all scales, from the internals of a mobile phone, to the massive data centres which serve web applications such as Google. This poses a substantial challenge for the software industry: writing correct and efficient programs for heterogeneous, highly parallel systems is much harder than for current technologies and most developers lack the skills and training to write safe and efficient code. Faced with this difficulty, software developers will often avoid writing parallel code completely, or else will use inappropriate, non-scalable and error-prone approaches based on explicit threads of program execution. Given the hardware trend towards increasingly complex, increasing parallel (manycore) systems, this is an inherently short-term strategy that is doomed to failure, Our project addresses this issue. Our key insight is that humans in general, are very good at using patterns to understand, predict and act in the real world. This insight translates into the world of software engineering in general, and parallel heterogeneous programming in particular. Our work will help programmers to recognize patterns in pre-existing and new applications, and to transform these pattern occurrences into forms which allow them to be exploited, adapted and run effectively on the new hardware platforms. The systems we develop will work in partnership with software developers, reducing the complexity of the task, automating and semi-automating the development task. The result will help the industry to develop new applications, and to update existing applications, with less effort, fewer errors and better resilience as the underlying technology continues to evolve.