Cross-Kernel Control-Flow–Graph Analysis for Event-Driven Real-Time Systems

Publikation: Beitrag in Buch/Bericht/Sammelwerk/KonferenzbandAufsatz in KonferenzbandForschungPeer-Review

Autoren

  • Christian Dietrich
  • Martin Hoffmann
  • Daniel Lohmann

Externe Organisationen

  • Friedrich-Alexander-Universität Erlangen-Nürnberg (FAU Erlangen-Nürnberg)
Forschungs-netzwerk anzeigen

Details

OriginalspracheEnglisch
Titel des SammelwerksLCTES'15: Proceedings of the 16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers and Tools for Embedded Systems 2015
Herausgeber (Verlag)Association for Computing Machinery (ACM)
Seiten58-67
Seitenumfang10
ISBN (elektronisch)9781450332576
PublikationsstatusVeröffentlicht - Juni 2015
Extern publiziertJa
Veranstaltung16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers, Tools and Theory for Embedded Systems, LCTES 2015 - Portland, USA / Vereinigte Staaten
Dauer: 18 Juni 201519 Juni 2015

Abstract

Embedded real-time control systems generally have a dedicated purpose and fixed set of functionalities. This manifests in a large amount of implicit and explicit static knowledge, available already at compile time. Modern compilers can extract and exploit this information to perform extensive whole-program analyses and inter-procedural optimizations. However, these analyses typically end at the application-kernel boundary, thus control-flow transitions between different threads are not covered, yet. This restriction stems from the pessimistic assumption of a probabilistic scheduling policy of the underlying operating system, impeding detailed predictions of the overall system behavior. Real-time operating systems, however, do provide deterministic and exactly specified scheduling decisions, as embedded control systems rely on a timely and precise behavior. In this paper, we present an approach that incorporates the RTOS semantics into the control-flow analysis, to cross the application-kernel boundary. By combining operating system semantics, the static system configuration and the application logic, we determine a cross-kernel control-flow-graph, that provides a global view on all possible execution paths of a real-time system. Having this knowledge at hand, enables us to tailor the operating system kernel more closely to the particular application scenario. On the example of a real-world safety-critical control system, we present two possible use cases: Run-time optimizations, by means of specialized system calls for each call site, allow to speed up the kernel execution path by 33 percent in our benchmark scenario. An automated generation of OS state assertions on the expected system behavior, targeting transient hardware fault tolerance, leverages significant robustness improvements.

ASJC Scopus Sachgebiete

Zitieren

Cross-Kernel Control-Flow–Graph Analysis for Event-Driven Real-Time Systems. / Dietrich, Christian; Hoffmann, Martin; Lohmann, Daniel.
LCTES'15: Proceedings of the 16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers and Tools for Embedded Systems 2015. Association for Computing Machinery (ACM), 2015. S. 58-67.

Publikation: Beitrag in Buch/Bericht/Sammelwerk/KonferenzbandAufsatz in KonferenzbandForschungPeer-Review

Dietrich, C, Hoffmann, M & Lohmann, D 2015, Cross-Kernel Control-Flow–Graph Analysis for Event-Driven Real-Time Systems. in LCTES'15: Proceedings of the 16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers and Tools for Embedded Systems 2015. Association for Computing Machinery (ACM), S. 58-67, 16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers, Tools and Theory for Embedded Systems, LCTES 2015, Portland, USA / Vereinigte Staaten, 18 Juni 2015. https://doi.org/10.1145/2670529.2754963
Dietrich, C., Hoffmann, M., & Lohmann, D. (2015). Cross-Kernel Control-Flow–Graph Analysis for Event-Driven Real-Time Systems. In LCTES'15: Proceedings of the 16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers and Tools for Embedded Systems 2015 (S. 58-67). Association for Computing Machinery (ACM). https://doi.org/10.1145/2670529.2754963
Dietrich C, Hoffmann M, Lohmann D. Cross-Kernel Control-Flow–Graph Analysis for Event-Driven Real-Time Systems. in LCTES'15: Proceedings of the 16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers and Tools for Embedded Systems 2015. Association for Computing Machinery (ACM). 2015. S. 58-67 doi: 10.1145/2670529.2754963
Dietrich, Christian ; Hoffmann, Martin ; Lohmann, Daniel. / Cross-Kernel Control-Flow–Graph Analysis for Event-Driven Real-Time Systems. LCTES'15: Proceedings of the 16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers and Tools for Embedded Systems 2015. Association for Computing Machinery (ACM), 2015. S. 58-67
Download
@inproceedings{6f87529aaf4a4892aa7d27aae1d0e6c1,
title = "Cross-Kernel Control-Flow–Graph Analysis for Event-Driven Real-Time Systems",
abstract = "Embedded real-time control systems generally have a dedicated purpose and fixed set of functionalities. This manifests in a large amount of implicit and explicit static knowledge, available already at compile time. Modern compilers can extract and exploit this information to perform extensive whole-program analyses and inter-procedural optimizations. However, these analyses typically end at the application-kernel boundary, thus control-flow transitions between different threads are not covered, yet. This restriction stems from the pessimistic assumption of a probabilistic scheduling policy of the underlying operating system, impeding detailed predictions of the overall system behavior. Real-time operating systems, however, do provide deterministic and exactly specified scheduling decisions, as embedded control systems rely on a timely and precise behavior. In this paper, we present an approach that incorporates the RTOS semantics into the control-flow analysis, to cross the application-kernel boundary. By combining operating system semantics, the static system configuration and the application logic, we determine a cross-kernel control-flow-graph, that provides a global view on all possible execution paths of a real-time system. Having this knowledge at hand, enables us to tailor the operating system kernel more closely to the particular application scenario. On the example of a real-world safety-critical control system, we present two possible use cases: Run-time optimizations, by means of specialized system calls for each call site, allow to speed up the kernel execution path by 33 percent in our benchmark scenario. An automated generation of OS state assertions on the expected system behavior, targeting transient hardware fault tolerance, leverages significant robustness improvements.",
keywords = "AUTOSAR, Global control-flow graph, OSEK, Static analysis, Static system tailoring, Whole-system optimization",
author = "Christian Dietrich and Martin Hoffmann and Daniel Lohmann",
year = "2015",
month = jun,
doi = "10.1145/2670529.2754963",
language = "English",
pages = "58--67",
booktitle = "LCTES'15: Proceedings of the 16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers and Tools for Embedded Systems 2015",
publisher = "Association for Computing Machinery (ACM)",
address = "United States",
note = "16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers, Tools and Theory for Embedded Systems, LCTES 2015 ; Conference date: 18-06-2015 Through 19-06-2015",

}

Download

TY - GEN

T1 - Cross-Kernel Control-Flow–Graph Analysis for Event-Driven Real-Time Systems

AU - Dietrich, Christian

AU - Hoffmann, Martin

AU - Lohmann, Daniel

PY - 2015/6

Y1 - 2015/6

N2 - Embedded real-time control systems generally have a dedicated purpose and fixed set of functionalities. This manifests in a large amount of implicit and explicit static knowledge, available already at compile time. Modern compilers can extract and exploit this information to perform extensive whole-program analyses and inter-procedural optimizations. However, these analyses typically end at the application-kernel boundary, thus control-flow transitions between different threads are not covered, yet. This restriction stems from the pessimistic assumption of a probabilistic scheduling policy of the underlying operating system, impeding detailed predictions of the overall system behavior. Real-time operating systems, however, do provide deterministic and exactly specified scheduling decisions, as embedded control systems rely on a timely and precise behavior. In this paper, we present an approach that incorporates the RTOS semantics into the control-flow analysis, to cross the application-kernel boundary. By combining operating system semantics, the static system configuration and the application logic, we determine a cross-kernel control-flow-graph, that provides a global view on all possible execution paths of a real-time system. Having this knowledge at hand, enables us to tailor the operating system kernel more closely to the particular application scenario. On the example of a real-world safety-critical control system, we present two possible use cases: Run-time optimizations, by means of specialized system calls for each call site, allow to speed up the kernel execution path by 33 percent in our benchmark scenario. An automated generation of OS state assertions on the expected system behavior, targeting transient hardware fault tolerance, leverages significant robustness improvements.

AB - Embedded real-time control systems generally have a dedicated purpose and fixed set of functionalities. This manifests in a large amount of implicit and explicit static knowledge, available already at compile time. Modern compilers can extract and exploit this information to perform extensive whole-program analyses and inter-procedural optimizations. However, these analyses typically end at the application-kernel boundary, thus control-flow transitions between different threads are not covered, yet. This restriction stems from the pessimistic assumption of a probabilistic scheduling policy of the underlying operating system, impeding detailed predictions of the overall system behavior. Real-time operating systems, however, do provide deterministic and exactly specified scheduling decisions, as embedded control systems rely on a timely and precise behavior. In this paper, we present an approach that incorporates the RTOS semantics into the control-flow analysis, to cross the application-kernel boundary. By combining operating system semantics, the static system configuration and the application logic, we determine a cross-kernel control-flow-graph, that provides a global view on all possible execution paths of a real-time system. Having this knowledge at hand, enables us to tailor the operating system kernel more closely to the particular application scenario. On the example of a real-world safety-critical control system, we present two possible use cases: Run-time optimizations, by means of specialized system calls for each call site, allow to speed up the kernel execution path by 33 percent in our benchmark scenario. An automated generation of OS state assertions on the expected system behavior, targeting transient hardware fault tolerance, leverages significant robustness improvements.

KW - AUTOSAR

KW - Global control-flow graph

KW - OSEK

KW - Static analysis

KW - Static system tailoring

KW - Whole-system optimization

UR - http://www.scopus.com/inward/record.url?scp=84951943239&partnerID=8YFLogxK

U2 - 10.1145/2670529.2754963

DO - 10.1145/2670529.2754963

M3 - Conference contribution

AN - SCOPUS:84951943239

SP - 58

EP - 67

BT - LCTES'15: Proceedings of the 16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers and Tools for Embedded Systems 2015

PB - Association for Computing Machinery (ACM)

T2 - 16th ACM SIGPLAN/SIGBED Conference on Languages, Compilers, Tools and Theory for Embedded Systems, LCTES 2015

Y2 - 18 June 2015 through 19 June 2015

ER -