A large fraction of the costs of developing and maintaining software is associated with detecting and fixing software errors. As a result, the last decade has seen a sustained research effort directed toward designing and developing techniques for automatically detecting software errors, with some of these techniques making their way into commercial and open-source tools. However, detecting an error is only the first step toward fixing it. In fact, many known errors remain unpatched due to the high cost required to diagnose and repair them, combined with the fear that patches are more likely to introduce failures compared to other types of code changes. The goal of this research project is to address both of these problems, by devising novel techniques based on dynamic symbolic execution for: (1) automatically testing and verifying the correctness of software patches, and (2) (semi-)automatically generating candidate patches for software bugs. The strength of dynamic symbolic execution lies in its ability to precisely model the behaviour of program paths using mathematical constraints. However, the cost associated with this level of precision is poor scalability. The number of paths in a program is usually exponential in the number of branches, which makes it difficult to scale the analysis to very large programs. However, by focusing the analysis on the incremental changes introduced by program patches, we hope to significantly reduce the cost of symbolic execution and significantly increase its applicability in practice. Furthermore, the ability to check software patches opens up the possibility of performing patch generation in an automatic or semi-automatic fashion. In particular, starting from the mathematical constraints gathered from a buggy execution path -- and with the potential addition of a manually-written patch template -- we plan to design techniques for generating a set of candidate patches resembling the ones that would be generated manually by developers.

We propose to establish a design and development working group (DDWG) to cover exascale science topics in experimental high energy physics (HEP). The HEP computing usage is currently at the preExascale stage and the participation to ExCALIBUR will enable exchange of ideas and good practice with other Sciences at a similar scale to ours. This proposal is put forward by the UK HEP community and aims to foster collaboration with colleagues from other communities. During the first phase of ExCALIBUR the HEP DDWG will provide demonstrators of exascale algorithms and data management infrastructure for the benefit of HEP and beyond. These activities follow the ExCALIBUR four pillars approach and are chosen to provide high research impact in areas of UK leadership evolving towards exascale science in the 2020s. Attachments with full details: - Case for Support - Justification of Resources - Track Record - Workplan - Pathways to Impact Project partners: - StackHPC (letter attached) - Maxeller (letter attached) Support letters: - Joint letter from Worldwide LHC Computing Grid, Hep Software Foundation, IRIS-HEP (international support) - Letter from the Alan Turing Institute

Our team specialises in the development of finite element methods to computationally simulate fluid flow, particularly low Mach number, transient, separated fluid flows in complex geometries and in the presence of strong multiphysics coupling. These models can be used to make predictions and answer scientific questions in problems ranging from blood flow through an arterial bypass graft to the flow over components of a Formula 1 racing car to explaining how the ocean circulates or predicting the response of the Earth's climate to increased CO2 in the atmosphere. What unifies these flows is that they have common features, such as vortices, that occur across a huge range of sizes and times; these features have a critical effect on the phenomena being studied. The range of these problem means that to address grand challenges such as the flow of blood in the numerous arteries of the human body, over a full Formula 1 car or the interaction of a massive array of tidal turbines, it is necessary to combine state-of-the-art modelling techniques with the capability to run models on massively parallel supercomputers. In recognition of the recent changes in computer hardware, this platform will enable the group to promote the next generation of developers to provide general purpose software that takes advantage of cutting edge computer science to enable effective use of parallel computers using emerging hardware in a way that is accessible to fluid modelling experts as well as computer scientists. Hence this platform brings together a team of computer scientists and computational engineers in a fundamentally multidisciplinary project, with the dual aim of providing flexible, internationally respected and widely adopted software libraries, and of training young researchers in this emerging area.

Modern computing systems are becoming increasingly diverse, but the common feature of all emerging computing platforms is the increased potential for performing many computations in parallel, by providing large numbers of processor cores. Computer systems consisting of various different platforms have great potential for performing tasks fast and efficiently. However, programming such systems is a great challenge. The era of performance increase through increased clock speeds has come to an end and we have entered a period where performance increases can only come from increased numbers of heterogeneous computational cores and their effective exploitation by software. Because of the immense effort required to adapt existing parallel software to novel hardware architectures with present technology, there is a very real danger that future advances in hardware performance will have little impact on practical large-scale computing using legacy software. The specific challenge that we want to address in this proposal is how to exploit the parallelism of a given computing platform, e.g. a multicore CPU, a graphics processor (GPU) or a Field-Programmable Gate Array (FPGA), in the best possible way, without having to change the original program. These different platforms have very different properties in terms of the available parallelism, depending on the nature and organisation of the processing cores and the memory. In particular FPGAs have great potential for parallelism but they are radically different in architecture from mainstream processors. This makes them very difficult to program. The key problem here is how to transform a program so that it will best use the potential for parallelism provided by the computing platform, and crucially, how to do this so that the resulting program is guaranteed to have the same behaviour as the original program. Our proposed approach is to use an advanced type system called Multi-Party Session Types to describe the communication between the tasks that make up a computation. To use a rough analogy, the computation could for instance be viewed as a car assembly line, where every unit performs a particular task such as painting, inserting doors, wheels, motor etc. Depending on the organisation and composition of the factory, the order in which these operations is performed will determine the speed with which a car can be assembled. However, when reordering the operations, one must of course ensure that changing the order does not lead to incorrect assembly. To return to the computational problem, by using the Multi-Party Session Types to describe the communication, we have a formal way of reasoning about the transformations. By developing a formal language for the transformations we can prove their correctness. This is the main novelty of the proposal: the formal system for type transformations. The actual transformations can be viewed as "programs" in this formal language. They will be informed by the properties of the computing platform. To provide this link between the transformation and the platform, we will also develop a formal description of parallel computing platforms. By building these formal systems into a compiler we will be able to transform programs to run in the most efficient way on hybrid manycore platforms. The main benefit from the proposed research is that the programmer will not need to have in-depth knowledge of the highly complex architecture of a hybrid manycore platform. This will be of great benefit to in particular scientific computing, because it also means that programs will not need to be rewritten to run with best performance on novel systems. To demonstrate the effectiveness of our approach we aim to develop a proof-of-concept compiler which will transform programs so that they can run on FPGAs, because this type of computing platform is the most different from other platforms and hence the most challenging.

SONNETS - Scalability Oriented Novel Networks of Event Triggered Systems - takes a clean-slate approach to next-generation computer modelling and artificial intelligence. To drive this we have an over-arching research goal that is both nationally important and challenging: real-time modelling of UK financial risk. It is easy to identify underlying risks after they cause a financial crisis. With hindsight, the 2008 financial crash was caused by too many banks buying too many risky mortgages. Whilst the crisis was unfolding it was all new information: no-one realised how many banks owned the risky mortgages. Then it was assumed that mortgage defaults were unlikely. Finally, it was assumed that losses in a few banks would not affect the national economy. The problem was a lack of visibility and understanding of the national picture: each bank appeared to have a manageable risk level, but most banks in the UK were exposed to the same underlying risk factor, so once mortgages started defaulting most banks started losing money and a perfect financial storm developed. What we needed then, and still do now, is national-level risk modelling that can consider risk across banks as it occurs. Modelling risk for one bank is a difficult problem, and modelling the entire UK is much harder. Banks have complex constantly changing portfolios, so building a picture of "who owns what" means tracking millions of trades per day. Even if we have that picture we still need to somehow assess risk, but that requires anticipating the future: we must pre-emptively identify potential scenarios, then estimate how much is lost in each scenario. Currently regulators use "stress tests" to identify national risk - they define a possible challenging economic scenario, then ask all the banks to estimate how much they might lose. However, this is both slow - the process takes months - and limited - they only explore one very severe scenario, which probably isn't the one that causes the problem. SONNETS will create a system that performs national-level risk analysis in real-time, by building a "digital twin" of the UK's financial system and using it to continually generate plausible future scenarios and assess their risk. We then use artificial intelligence to learn what risky scenarios look like. This gives regulators completely new tools: - A day-by-day view of the current national-risk of the UK, rather than waiting months for stress tests; - The ability to look forwards to identify and mitigate previously unknown risks as they develop, rather than waiting for a financial crisis to reveal them. We tackle this problem by addressing challenges in three main areas: - Computing: new paradigms for creating and running programs, exploiting multiple types of computer hardware distributed across the cloud; - Artificial Intelligence: methods for continual learning that can be split into multiple pieces, so that learning processes can be moved closer to the data they are learning from; - Modelling: theory and tools for automatic scenario generation, plus the ability to assess risk over large-scale models of the UK's financial institutions. These three areas are tightly linked, with the new computing paradigms supporting execution of the new AI and modelling in the cloud, and a synergistic relationship between the modelling of the system and learning about the model. Underpinning these three areas is the idea of event-triggered computing, where programs are split up into small fragments which send messages to each other. Using this event-triggered approach we can scale the risk analysis system up to support national-level risk analysis. It will constantly assess how risky the UK currently is, while trying to anticipate what scenarios might lead to financial crises in the future. SONNETS will provide a powerful tool to detect and mitigate financial risk as it is building up, rather than trying to react to a financial crisis once it happens.