Network


Latest external collaboration on country level. Dive into details by clicking on the dots.

Hotspot


Dive into the research topics where Jeremy Morse is active.

Publication


Featured researches published by Jeremy Morse.


software and compilers for embedded systems | 2015

Static analysis of energy consumption for LLVM IR programs

Neville Grech; Kyriakos Georgiou; James Pallister; Steve Kerrison; Jeremy Morse; Kerstin Eder

Energy models can be constructed by characterizing the energy consumed by executing each instruction in a processor’s instruction set. This can be used to determine how much energy is required to execute a sequence of assembly instructions, without the need to instrument or measure hardware. However, statically analyzing low-level program structures is hard, and the gap between the high-level program structure and the low-level energy models needs to be bridged. We have developed techniques for performing a static analysis on the intermediate compiler representations of a program. Specifically, we target LLVM IR, a representation used by modern compilers, including Clang. Using these techniques we can automatically infer an estimate of the energy consumed when running a function under different platforms, using different compilers. One of the challenges in doing so is that of determining an energy cost of executing LLVM IR program segments, for which we have developed two different approaches. When this information is used in conjunction with our analysis, we are able to infer energy formulae that characterize the energy consumption for a particular program. This approach can be applied to any languages targeting the LLVM toolchain, including C and XC or architectures such as ARM Cortex-M or XMOS xCORE, with a focus towards embedded platforms. Our techniques are validated on these platforms by comparing the static analysis results to the physical measurements taken from the hardware. Static energy consumption estimation enables energy-aware software development, without requiring hardware knowledge.Energy models can be constructed by characterizing the energy consumed when executing each instruction in a processors instruction set. This can be used to determine how much energy is required to execute a sequence of assembly instructions, without the need to instrument or measure hardware. However, statically analyzing low-level program structures is hard, and the gap between the high-level program structure and the low-level energy models needs to be bridged. We have developed techniques for performing a static analysis on the intermediate compiler representations of a program. Specifically, we target LLVM IR, a representation used by modern compilers, including Clang. Using these techniques we can automatically infer an estimate of the energy consumed when running a function under different platforms and compilers. One of the challenges in doing so is that of determining the energy cost of executing LLVM IR program segments, for which we have developed two different approaches. When this information is used in conjunction with our analysis, we are able to infer energy formulae that characterize the energy consumption for a particular program. This approach can be applied to any languages targeting the LLVM toolchain, including C and XC or architectures such as ARM Cortex-M or XMOS xCORE, with a focus towards embedded platforms. Our techniques are validated on these platforms by comparing the static analysis results to the physical measurements taken from the hardware. Static energy consumption estimation enables energy-aware software development by providing instant feedback to the developer, without requiring simulations or hardware knowledge.


tools and algorithms for construction and analysis of systems | 2013

Handling unbounded loops with ESBMC 1.20

Jeremy Morse; Lucas C. Cordeiro; Denis A. Nicole; Bernd Fischer

We extended ESBMC to exploit the combination of context-bounded symbolic model checking and k-induction to prove safety properties in single- and multi-threaded ANSI-C programs with unbounded loops. We now first try to verify by induction that the safety property holds in the system. If that fails, we search for a bounded reachable state that constitutes a counterexample.


tools and algorithms for construction and analysis of systems | 2012

Context-Bounded model checking with ESBMC 1.17

Lucas C. Cordeiro; Jeremy Morse; Denis A. Nicole; Bernd Fischer

ESBMC is a context-bounded symbolic model checker for single- and multi-threaded ANSI-C code. It converts the verification conditions using different background theories and passes them directly to an SMT solver.


Software and Systems Modeling | 2015

Model checking LTL properties over ANSI-C programs with bounded traces

Jeremy Morse; Lucas C. Cordeiro; Denis A. Nicole; Bernd Fischer

Context-bounded model checking has been used successfully to verify safety properties in multi-threaded systems automatically, even if they are implemented in low-level programming languages such as C. In this paper, we describe and experiment with an approach to extend context-bounded software model checking to safety and liveness properties expressed in linear-time temporal logic (LTL). Our approach checks the actual C program, rather than an extracted abstract model. It converts the LTL formulas into Büchi automata for the corresponding never claims and then further into C monitor threads that are interleaved with the execution of the program under analysis. This combined system is then checked using the ESBMC model checker. We use an extended, four-valued LTL semantics to handle the finite traces that bounded model checking explores; we thus check the combined system several times with different acceptance criteria to derive the correct truth value. In order to mitigate the state space explosion, we use a dedicated scheduler that selects the monitor thread only after updates to global variables occurring in the LTL formula. We demonstrate our approach on the analysis of the sequential firmware of a medical device and a small multi-threaded control application.


international conference on software engineering | 2011

Context-bounded model checking of LTL properties for ANSI-C software

Jeremy Morse; Lucas C. Cordeiro; Denis A. Nicole; Bernd Fischer

Context-bounded model checking has successfully been used to verify safety properties in multi-threaded systems automatically, even if they are implemented in low-level programming languages like ANSIC. In this paper, we describe and experiment with an approach to extend context-bounded model checking to liveness properties expressed in linear-time temporal logic (LTL). Our approach converts the LTL formulae into Buchi-automata and then further into C monitor threads, which are interleaved with the execution of the program under test. This combined system is then checked using the ESBMC model checker. Since this approach explores a larger number of interleavings than normal context-bounded model checking, we use a state hashing technique which substantially reduces the number of redundant interleavings that are explored and so mitigates state space explosion. Our experimental results show that we can verify non-trivial properties in the firmware of a medical device.


tools and algorithms for construction and analysis of systems | 2014

ESBMC 1.22

Jeremy Morse; Mikhail Ramalho; Lucas C. Cordeiro; Denis A. Nicole; Bernd Fischer

We have implemented an improved memory model for ESBMC which better takes into account C’s memory alignment rules and optimizes the generated SMT formulae. This simultaneously improves ESBMC’s precision and performance.


software and compilers for embedded systems | 2017

Data Dependent Energy Modeling for Worst Case Energy Consumption Analysis

James Pallister; Steve Kerrison; Jeremy Morse; Kerstin Eder

Safely meeting Worst Case Energy Consumption (WCEC) criteria requires accurate energy modeling of software. We investigate the impact of instruction operand values upon energy consumption in cacheless embedded processors. Existing instruction-level energy models typically use measurements from random input data, providing estimates unsuitable for safe WCEC analysis. We examine probabilistic energy distributions of instructions and propose a model for composing instruction sequences using distributions, enabling WCEC analysis on program basic blocks. The worst case is predicted with statistical analysis. Further, we verify that the energy of embedded benchmarks can be characterised as a distribution, and compare our proposed technique with other methods of estimating energy consumption.


Microprocessors and Microsystems | 2016

ENTRA: Whole-systems energy transparency

Kerstin Eder; John P. Gallagher; Pedro López-García; Henk L. Muller; Zorana Bankovic; Kyriakos Georgiou; R. Haemmerlé; Manuel V. Hermenegildo; Bishoksan Kafle; Steve Kerrison; Maja Hanne Kirkeby; Maximiliano Klemen; Xueliang Li; Umer Liqat; Jeremy Morse; Morten Rhiger; Mads Rosendahl

Abstract Promoting energy efficiency to a first class system design goal is an important research challenge. Although more energy-efficient hardware can be designed, it is software that controls the hardware; for a given system the potential for energy savings is likely to be much greater at the higher levels of abstraction in the system stack. Thus the greatest savings are expected from energy-aware software development, which is the vision of the EU ENTRA project. This article presents the concept of energy transparency as a foundation for energy-aware software development. We show how energy modelling of hardware is combined with static analysis to allow the programmer to understand the energy consumption of a program without executing it, thus enabling exploration of the design space taking energy into consideration. The paper concludes by summarising the current and future challenges identified in the ENTRA project.


International Journal on Software Tools for Technology Transfer | 2014

Applying symbolic bounded model checking to the 2012 RERS greybox challenge

Jeremy Morse; Lucas C. Cordeiro; Denis A. Nicole; Bernd Fischer

We describe the application of ESBMC, a symbolic bounded model checker for C programs, to the 2012 RERS greybox challenge. We checked the reachability properties via reachability of the error labels, and the behavioral properties via a bounded LTL model checking approach. Our approach could solve about 700 properties for the small and medium problems from the offline phase, and scored overall about 5,000 marks but still ranked last in the competition.


automated software engineering | 2018

ESBMC 5.0: an industrial-strength C model checker

Mikhail Y. R. Gadelha; Felipe R. Monteiro; Jeremy Morse; Lucas C. Cordeiro; Bernd Fischer; Denis A. Nicole

ESBMC is a mature, permissively licensed open-source context-bounded model checker for the verification of single- and multithreaded C programs. It can verify both predefined safety properties (e.g., bounds check, pointer safety, overflow) and user-defined program assertions automatically. ESBMC provides C++ and Python APIs to access internal data structures, allowing inspection and extension at any stage of the verification process. We discuss improvements over previous versions of ESBMC, including the description of new front- and back-ends, IEEE floating-point support, and an improved k-induction algorithm. A demonstration is available at https://www.youtube.com/watch?v=YcJjXHlN1v8.

Collaboration


Dive into the Jeremy Morse's collaboration.

Top Co-Authors

Avatar
Top Co-Authors

Avatar

Denis A. Nicole

University of Southampton

View shared research outputs
Top Co-Authors

Avatar
Top Co-Authors

Avatar
Top Co-Authors

Avatar
Top Co-Authors

Avatar
Top Co-Authors

Avatar
Top Co-Authors

Avatar
Top Co-Authors

Avatar
Top Co-Authors

Avatar
Researchain Logo
Decentralizing Knowledge