Volume
OASIcs, Volume 114
21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)
-
Part of:
Series:
Open Access Series in Informatics (OASIcs)
Conference: Workshop on Worst-Case Execution Time Analysis (WCET)
Event
WCET 2023, July 11, 2023, Vienna, AustriaEditor
Publication Details
- published at: 2023-07-26
- Publisher: Schloss Dagstuhl – Leibniz-Zentrum für Informatik
- ISBN: 978-3-95977-293-8
- DBLP: db/conf/wcet/wcet2023
Access Numbers
- Detailed Access Statistics available here
-
Total Document Accesses (updated on a weekly basis):
0PDF Downloads
Documents
No documents found matching your filter selection.
Document
Complete Volume
OASIcs, Volume 114, WCET 2023, Complete Volume
Abstract
OASIcs, Volume 114, WCET 2023, Complete Volume
Cite as
21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 1-124, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@Proceedings{wagemann:OASIcs.WCET.2023,
title = {{OASIcs, Volume 114, WCET 2023, Complete Volume}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {1--124},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023},
URN = {urn:nbn:de:0030-drops-184285},
doi = {10.4230/OASIcs.WCET.2023},
annote = {Keywords: OASIcs, Volume 114, WCET 2023, Complete Volume}
}
Document
Front Matter
Front Matter, Table of Contents, Preface, Conference Organization
Abstract
Front Matter, Table of Contents, Preface, Conference Organization
Cite as
21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 0:i-0:x, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@InProceedings{wagemann:OASIcs.WCET.2023.0,
author = {W\"{a}gemann, Peter},
title = {{Front Matter, Table of Contents, Preface, Conference Organization}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {0:i--0:x},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023.0},
URN = {urn:nbn:de:0030-drops-184290},
doi = {10.4230/OASIcs.WCET.2023.0},
annote = {Keywords: Front Matter, Table of Contents, Preface, Conference Organization}
}
Document
Warp-Level CFG Construction for GPU Kernel WCET Analysis
Abstract
We present an abstract interpretation technique to automatically build a Control Flow Graph (CFG) representation of the execution of a GPU kernel. GPUs implement an inherently parallel execution model, in which threads are grouped within so-called warps that execute in lockstep. This execution model enables the representation of the execution of the threads of a warp as a single CFG. However, thread divergence may appear within a warp and its effect must be captured explicitly within the CFG. Our method builds the CFG of a warp by applying abstract interpretation on the assembly (Nvidia SASS) code of a kernel, and by maintaining an abstract representation of which threads within the warp agree on which values. This allows the method to detect precisely the points in the program where thread divergence may occur, and avoid spurious reactivation edges in the CFG. We apply our technique on benchmark kernels as a proof-of-concept, and generate IPET systems using the resulting CFGs.
Cite as
Louison Jeanmougin, Pascal Sotin, Christine Rochange, and Thomas Carle. Warp-Level CFG Construction for GPU Kernel WCET Analysis. In 21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 1:1-1:13, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@InProceedings{jeanmougin_et_al:OASIcs.WCET.2023.1,
author = {Jeanmougin, Louison and Sotin, Pascal and Rochange, Christine and Carle, Thomas},
title = {{Warp-Level CFG Construction for GPU Kernel WCET Analysis}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {1:1--1:13},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023.1},
URN = {urn:nbn:de:0030-drops-184303},
doi = {10.4230/OASIcs.WCET.2023.1},
annote = {Keywords: Graphical Processing Unit (GPU), Control Flow Graphs (CFG), Worst-Case Execution Time (WCET), Program analysis}
}
Document
Validation of Processor Timing Models Using Cycle-Accurate Timing Simulators
Abstract
We propose a workflow to help find errors in the processor models that are used to prove their timing predictability. Recently, several papers have modeled processor cores using formal models that represent how instructions progress through the pipeline in each execution cycle. However, such models grow with the complexity of the cores and they are built by hand, using a description of the core, usually the HDL-level code. Such a task is error-prone, and verifying that the model actually captures the core’s timing behavior is required, otherwise the proofs become useless. Our workflow simulates the execution of benchmark applications using the HDL specification of a core in order to extract timing information as well as other relevant information (e.g. cache miss events, branch mispredictions). This information is used to replay the execution in a simulator of the core timing model, and to determine whether or not the model accurately represents the execution timing of the instructions. To avoid writing the simulator by hand for each new core, or new variation of a core, we developed a compiler that translates the timing model of a core into a C++ program. We evaluated our approach on the open source MINOTAuR core and we show how it enabled us to detect and correct errors in its model.
Cite as
Alban Gruin, Thomas Carle, Christine Rochange, and Pascal Sainrat. Validation of Processor Timing Models Using Cycle-Accurate Timing Simulators. In 21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 2:1-2:12, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@InProceedings{gruin_et_al:OASIcs.WCET.2023.2,
author = {Gruin, Alban and Carle, Thomas and Rochange, Christine and Sainrat, Pascal},
title = {{Validation of Processor Timing Models Using Cycle-Accurate Timing Simulators}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {2:1--2:12},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023.2},
URN = {urn:nbn:de:0030-drops-184319},
doi = {10.4230/OASIcs.WCET.2023.2},
annote = {Keywords: Processor model, timing predictability, simulator generation}
}
Document
Exploring iGPU Memory Interference Response to L2 Cache Locking
Abstract
The demand of parallel execution in real-time embedded applications has motivated the integration of GPUs as processing accelerators on SoCs (System-on-Chip) embedded architectures, often leading to CPU-iGPU architectures. In the safety-critical domain, it is paramount to ensure that the execution deadlines of critical tasks are not exceeded. To ease the analysis of this kind of tasks, we can make their worst-case execution time more predictable. One way to achieve this is by mitigating or controlling the memory interference generated by the concurrent execution of tasks through the application of a series of techniques (e.g., cache partitioning, bank partitioning, cache locking, bandwidth regulation). Originally, these were applied to CPUs, and more recently, to GPUs as well. In this work, we focus on the hardware-based L2 cache locking on iGPUs as memory interference mitigation mechanism. We are interested in evaluating its capacity for reducing the worst-case and the average-case execution time in different scenarios. Our measurement-based analysis has been carried out on the NVIDIA’s Jetson AGX Orin 64 GB MPSoC, making use of four representative benchmarks (data resetting, 2D convolution, 3D convolution and matrix upsampling).
Cite as
Alfonso Mascareñas González, Jean-Baptiste Chaudron, Régine Leconte, Youcef Bouchebaba, and David Doose. Exploring iGPU Memory Interference Response to L2 Cache Locking. In 21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 3:1-3:11, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@InProceedings{gonzalez_et_al:OASIcs.WCET.2023.3,
author = {Gonz\'{a}lez, Alfonso Mascare\~{n}as and Chaudron, Jean-Baptiste and Leconte, R\'{e}gine and Bouchebaba, Youcef and Doose, David},
title = {{Exploring iGPU Memory Interference Response to L2 Cache Locking}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {3:1--3:11},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023.3},
URN = {urn:nbn:de:0030-drops-184321},
doi = {10.4230/OASIcs.WCET.2023.3},
annote = {Keywords: iGPU, cache locking, real-time, memory interference}
}
Document
Clustering Solutions of Multiobjective Function Inlining Problem
Abstract
Hard real time-systems are often small devices operating on batteries that must react within a given deadline, so they must satisfy their timing, code size, and energy consumption requirements. Since these three objectives contradict each other, compilers for real-time systems go towards multiobjective optimizations which result in sets of trade-off solutions. A system designer can use the solution sets to choose the most suitable system configuration. Evolutionary algorithms can find trade-off solutions but the solution set might be large which complicates the task of the system designer. We propose to divide the solution set into clusters, so the system designer chooses the most suitable cluster and examines a smaller subset in detail. In contrast to other clustering techniques, our method guarantees that the sizes of all clusters are less than a predefined limit. Our method clusters a set by using any existing clustering method, divides clusters with sizes exceeding the predefined size into smaller clusters, and reduces the number of clusters by merging small clusters. The method guarantees that the final clusters satisfy the size constraint. We demonstrate our approach by considering a well-known compiler-based optimization called function inlining. It substitutes function calls by the function bodies which decreases the execution time and energy consumption of a program but increases its code size.
Cite as
Kateryna Muts and Heiko Falk. Clustering Solutions of Multiobjective Function Inlining Problem. In 21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 4:1-4:12, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@InProceedings{muts_et_al:OASIcs.WCET.2023.4,
author = {Muts, Kateryna and Falk, Heiko},
title = {{Clustering Solutions of Multiobjective Function Inlining Problem}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {4:1--4:12},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023.4},
URN = {urn:nbn:de:0030-drops-184332},
doi = {10.4230/OASIcs.WCET.2023.4},
annote = {Keywords: Clustering, multiobjective optimization, compiler, hard real-time system}
}
Document
Efficient and Effective Multi-Objective Optimization for Real-Time Multi-Task Systems
Abstract
Embedded real-time multi-task systems must often not only comply with timing constraints but also need to meet energy requirements. However, optimizing energy consumption might lead to higher Worst-Case Execution Time (WCET), leading to an un-schedulable system, as frequently executed code can easily differ from timing-critical code. To handle such an impasse in this paper, we formulate a Metaheuristic Algorithm-based Multi-objective Optimization (MAMO) for multi-task real-time systems. But, performing multiple WCET, energy, and schedulability analyses to solve a MAMO poses a bottleneck concerning compilation times. Therefore, we propose two novel approaches - Path-based Constraint Approach (PCA) and Impact-based Constraint Approach (ICA) - to reduce the solution search space size and to cope with this problem. Evaluations showed that PCA and ICA reduced compilation times by 85.31% and 77.31%, on average, over MAMO. For all the task sets, out of all solutions found by ICA-FPA, on average, 88.89% were on the final Pareto front.
Cite as
Shashank Jadhav and Heiko Falk. Efficient and Effective Multi-Objective Optimization for Real-Time Multi-Task Systems. In 21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 5:1-5:12, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@InProceedings{jadhav_et_al:OASIcs.WCET.2023.5,
author = {Jadhav, Shashank and Falk, Heiko},
title = {{Efficient and Effective Multi-Objective Optimization for Real-Time Multi-Task Systems}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {5:1--5:12},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023.5},
URN = {urn:nbn:de:0030-drops-184340},
doi = {10.4230/OASIcs.WCET.2023.5},
annote = {Keywords: Real-time systems, Multi-objective optimization, Metaheuristic algorithms, Compilers, Design space reduction}
}
Document
Towards Multi-Objective Dynamic SPM Allocation
Abstract
Most real-time embedded systems are required to fulfill timing constraints while adhering to a limited energy budget. Small ScratchPad Memory (SPM) poses a common hardware constraint on embedded systems. Static SPM allocation techniques are limited by the SPM’s stringent size constraint, which is why this paper proposes a Dynamic SPM Allocation (DSA) model at the compiler level for the dynamic allocation of a program to SPM during runtime. To minimize Worst-Case Execution Time (WCET) and energy objectives, we propose a multi-objective DSA-based optimization. Static SPM allocations might inherently use SPM sub-optimally, while all proposed DSA optimizations are only single-objective. Therefore, this paper is the first step towards a DSA that trades WCET and energy objectives simultaneously. Even with extra DSA overheads, our approach provides better quality solutions than the state-of-the-art multi-objective static SPM allocation and ILP-based single-objective DSA approach.
Cite as
Shashank Jadhav and Heiko Falk. Towards Multi-Objective Dynamic SPM Allocation. In 21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 6:1-6:12, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@InProceedings{jadhav_et_al:OASIcs.WCET.2023.6,
author = {Jadhav, Shashank and Falk, Heiko},
title = {{Towards Multi-Objective Dynamic SPM Allocation}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {6:1--6:12},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023.6},
URN = {urn:nbn:de:0030-drops-184353},
doi = {10.4230/OASIcs.WCET.2023.6},
annote = {Keywords: Multi-objective optimization, Embedded systems, Compilers, Dynamic SPM allocation, Metaheuristic algorithms}
}
Document
Constant-Loop Dominators for Single-Path Code Optimization
Abstract
Single-path code is a code generation technique specifically designed for real-time systems. It guarantees that programs execute the same instruction sequence regardless of runtime conditions. Single-path code uses loop bounds to ensure all loops iterate a fixed number of times equal to their upper loop bound. When the lower and upper bounds are equal, the loop must iterate the same number of times, which we call a constant loop.
In this paper, we present the constant-loop dominance relation on control-flow graphs. It is a variation of the traditional dominance relation that considers constant loops to find basic blocks that are always executed the same number of times. Using this relation, we present an optimization that reduces the code needed to manage single-path code. Our evaluation shows significant performance improvements, with one example of up to 90%, with mostly minor effects on code size.
Cite as
Emad Jacob Maroun, Martin Schoeberl, and Peter Puschner. Constant-Loop Dominators for Single-Path Code Optimization. In 21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 7:1-7:13, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@InProceedings{maroun_et_al:OASIcs.WCET.2023.7,
author = {Maroun, Emad Jacob and Schoeberl, Martin and Puschner, Peter},
title = {{Constant-Loop Dominators for Single-Path Code Optimization}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {7:1--7:13},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023.7},
URN = {urn:nbn:de:0030-drops-184361},
doi = {10.4230/OASIcs.WCET.2023.7},
annote = {Keywords: single-path, dominators, algorithms, optimization, control-flow graph}
}
Document
Analyzing the Stability of Relative Performance Differences Between Cloud and Embedded Environments
Abstract
There has been a shift towards the software-defined vehicle in the automotive industry in recent years. In order to enable the correct behaviour of critical as well as non-critical software functions, like those found in Autonomous Driving/Driver Assistance subsystems, extensive software testing needs to be performed. The usage of embedded hardware for these tests is either very expensive or takes a prohibitively long time in relation to the fast development cycles in the industry. To reduce development bottlenecks, test frameworks executed in cloud environments that leverage the scalability of the cloud are an essential part of the development process. However, relying on more performant cloud hardware for the majority of tests means that performance problems will only become apparent in later development phases when software is deployed to the real target. However, if the performance relation between executing in the cloud and on the embedded target can be approximated with sufficient precision, the expressiveness of the executed tests can be improved. Moreover, as a fully integrated system consists of a large number of software components that, at any given time, exhibit an unknown mix of best-/average-/worst-case behaviour, it is critical to know whether the performance relation differs depending on the inputs. In this paper, we examine the relative performance differences between a physical ARM-based chipset and a cloud-based ARM-based virtual machine, using a generic benchmark and 2 algorithms representative of typical automotive workloads, modified to generate best-/average-/worst-case behaviour in a reproducible and controlled way and assess the performance differences. We determine that the performance difference factor is between 1.8 and 3.6 for synthetic benchmarks and around 2.0-2.8 for more representative benchmarks. These results indicate that it may be possible to relate cloud to embedded performance with acceptable precision, especially when workload characterization is taken into account.
Cite as
Rumen Rumenov Kolev and Christopher Helpa. Analyzing the Stability of Relative Performance Differences Between Cloud and Embedded Environments. In 21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 8:1-8:12, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@InProceedings{kolev_et_al:OASIcs.WCET.2023.8,
author = {Kolev, Rumen Rumenov and Helpa, Christopher},
title = {{Analyzing the Stability of Relative Performance Differences Between Cloud and Embedded Environments}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {8:1--8:12},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023.8},
URN = {urn:nbn:de:0030-drops-184373},
doi = {10.4230/OASIcs.WCET.2023.8},
annote = {Keywords: Performance Benchmarking, Performance Factor Stability, Software Development, Cloud Computing, WCET}
}
Document
EnergyAnalyzer: Using Static WCET Analysis Techniques to Estimate the Energy Consumption of Embedded Applications
Abstract
This paper presents EnergyAnalyzer, a code-level static analysis tool for estimating the energy consumption of embedded software based on statically predictable hardware events. The tool utilises techniques usually used for worst-case execution time (WCET) analysis together with bespoke energy models developed for two predictable architectures - the ARM Cortex-M0 and the Gaisler LEON3 - to perform energy usage analysis. EnergyAnalyzer has been applied in various use cases, such as selecting candidates for an optimised convolutional neural network, analysing the energy consumption of a camera pill prototype, and analysing the energy consumption of satellite communications software. The tool was developed as part of a larger project called TeamPlay, which aimed to provide a toolchain for developing embedded applications where energy properties are first-class citizens, allowing the developer to reflect directly on these properties at the source code level. The analysis capabilities of EnergyAnalyzer are validated across a large number of benchmarks for the two target architectures and the results show that the statically estimated energy consumption has, with a few exceptions, less than 1% difference compared to the underlying empirical energy models which have been validated on real hardware.
Cite as
Simon Wegener, Kris K. Nikov, Jose Nunez-Yanez, and Kerstin Eder. EnergyAnalyzer: Using Static WCET Analysis Techniques to Estimate the Energy Consumption of Embedded Applications. In 21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023). Open Access Series in Informatics (OASIcs), Volume 114, pp. 9:1-9:14, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)
Copy BibTex To Clipboard
@InProceedings{wegener_et_al:OASIcs.WCET.2023.9,
author = {Wegener, Simon and Nikov, Kris K. and Nunez-Yanez, Jose and Eder, Kerstin},
title = {{EnergyAnalyzer: Using Static WCET Analysis Techniques to Estimate the Energy Consumption of Embedded Applications}},
booktitle = {21th International Workshop on Worst-Case Execution Time Analysis (WCET 2023)},
pages = {9:1--9:14},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-293-8},
ISSN = {2190-6807},
year = {2023},
volume = {114},
editor = {W\"{a}gemann, Peter},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops-dev.dagstuhl.de/entities/document/10.4230/OASIcs.WCET.2023.9},
URN = {urn:nbn:de:0030-drops-184380},
doi = {10.4230/OASIcs.WCET.2023.9},
annote = {Keywords: Energy Modelling, Static Analysis, Gaisler LEON3, ARM Cortex-M0}
}