Loading [MathJax]/extensions/tex2jax.js

A JVM for Soft-Error-Prone Embedded Systems

Research output: Chapter in book/report/conference proceedingConference contributionResearchpeer review

Authors

  • Isabella Stilkerich
  • Michael Strotz
  • Christoph Erhardt
  • Martin Hoffmann
  • Daniel Lohmann

External Research Organisations

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

Details

Original languageEnglish
Title of host publicationLCTES '13: Proceedings of the 14th ACM SIGPLAN/SIGBED conference on Languages, compilers and tools for embedded systems
Pages21-31
Number of pages11
Publication statusPublished - Jun 2013
Externally publishedYes
Event14th ACM SIGPLAN/SIGBED Conference on Languages, Compilers, Tools and Theory for Embedded Systems, LCTES 2013 - Seattle, WA, United States
Duration: 20 Jun 201321 Jun 2013

Abstract

The reduction of structure sizes in microcontollers, environmental conditions or low supply voltages increase the susceptibility of embedded systems to soft errors. As a result, the employment of fault-detection and fault-tolerance measures is becoming a mandatory task even for moderately critical applications. Accordingly, software-based techniques have recently gained in popularity, and a multitude of approaches that differ in the number and frequency of tolerated errors as well as their associated overhead have been proposed. Using type-safe programming languages to isolate critical software components is very popular among those techniques. An automated application of fault-detection and fault-tolerance measures based on the type system of the programming language and static code analyses is possible. It facilitates an easy evaluation of the protection characteristics and costs as well as the migration of software to new hardware platforms with different failure rates. Transient faults, however, are not bound to the application code secured by the type system, but can also affect the correctness of the type system itself. Thereby, the type system might lose its ability to isolate critical components. As a consequence, it is essential to also protect the type system itself against soft errors. In this paper, we show how soft errors can affect the integrity of the type system. Furthermore, we provide means to secure it against these faults, thus preserving its isolating character. These measures can be applied selectively to achieve a suitable tradeoff between level of protection and resource consumption.

Keywords

    Embedded systems, Java, KESO, Real-time systems, Reliability, RTSJ

ASJC Scopus subject areas

Cite this

A JVM for Soft-Error-Prone Embedded Systems. / Stilkerich, Isabella; Strotz, Michael; Erhardt, Christoph et al.
LCTES '13: Proceedings of the 14th ACM SIGPLAN/SIGBED conference on Languages, compilers and tools for embedded systems. 2013. p. 21-31.

Research output: Chapter in book/report/conference proceedingConference contributionResearchpeer review

Stilkerich, I, Strotz, M, Erhardt, C, Hoffmann, M, Lohmann, D, Scheler, F & Schröder-Preikschat, W 2013, A JVM for Soft-Error-Prone Embedded Systems. in LCTES '13: Proceedings of the 14th ACM SIGPLAN/SIGBED conference on Languages, compilers and tools for embedded systems. pp. 21-31, 14th ACM SIGPLAN/SIGBED Conference on Languages, Compilers, Tools and Theory for Embedded Systems, LCTES 2013, Seattle, WA, United States, 20 Jun 2013. https://doi.org/10.1145/2465554.2465571
Stilkerich, I., Strotz, M., Erhardt, C., Hoffmann, M., Lohmann, D., Scheler, F., & Schröder-Preikschat, W. (2013). A JVM for Soft-Error-Prone Embedded Systems. In LCTES '13: Proceedings of the 14th ACM SIGPLAN/SIGBED conference on Languages, compilers and tools for embedded systems (pp. 21-31) https://doi.org/10.1145/2465554.2465571
Stilkerich I, Strotz M, Erhardt C, Hoffmann M, Lohmann D, Scheler F et al. A JVM for Soft-Error-Prone Embedded Systems. In LCTES '13: Proceedings of the 14th ACM SIGPLAN/SIGBED conference on Languages, compilers and tools for embedded systems. 2013. p. 21-31 doi: 10.1145/2465554.2465571
Stilkerich, Isabella ; Strotz, Michael ; Erhardt, Christoph et al. / A JVM for Soft-Error-Prone Embedded Systems. LCTES '13: Proceedings of the 14th ACM SIGPLAN/SIGBED conference on Languages, compilers and tools for embedded systems. 2013. pp. 21-31
Download
@inproceedings{2cfa4699babd4eb9a8ae963c325b27cf,
title = "A JVM for Soft-Error-Prone Embedded Systems",
abstract = "The reduction of structure sizes in microcontollers, environmental conditions or low supply voltages increase the susceptibility of embedded systems to soft errors. As a result, the employment of fault-detection and fault-tolerance measures is becoming a mandatory task even for moderately critical applications. Accordingly, software-based techniques have recently gained in popularity, and a multitude of approaches that differ in the number and frequency of tolerated errors as well as their associated overhead have been proposed. Using type-safe programming languages to isolate critical software components is very popular among those techniques. An automated application of fault-detection and fault-tolerance measures based on the type system of the programming language and static code analyses is possible. It facilitates an easy evaluation of the protection characteristics and costs as well as the migration of software to new hardware platforms with different failure rates. Transient faults, however, are not bound to the application code secured by the type system, but can also affect the correctness of the type system itself. Thereby, the type system might lose its ability to isolate critical components. As a consequence, it is essential to also protect the type system itself against soft errors. In this paper, we show how soft errors can affect the integrity of the type system. Furthermore, we provide means to secure it against these faults, thus preserving its isolating character. These measures can be applied selectively to achieve a suitable tradeoff between level of protection and resource consumption.",
keywords = "Embedded systems, Java, KESO, Real-time systems, Reliability, RTSJ",
author = "Isabella Stilkerich and Michael Strotz and Christoph Erhardt and Martin Hoffmann and Daniel Lohmann and Fabian Scheler and Wolfgang Schr{\"o}der-Preikschat",
year = "2013",
month = jun,
doi = "10.1145/2465554.2465571",
language = "English",
isbn = "9781450320856",
pages = "21--31",
booktitle = "LCTES '13: Proceedings of the 14th ACM SIGPLAN/SIGBED conference on Languages, compilers and tools for embedded systems",
note = "14th ACM SIGPLAN/SIGBED Conference on Languages, Compilers, Tools and Theory for Embedded Systems, LCTES 2013 ; Conference date: 20-06-2013 Through 21-06-2013",

}

Download

TY - GEN

T1 - A JVM for Soft-Error-Prone Embedded Systems

AU - Stilkerich, Isabella

AU - Strotz, Michael

AU - Erhardt, Christoph

AU - Hoffmann, Martin

AU - Lohmann, Daniel

AU - Scheler, Fabian

AU - Schröder-Preikschat, Wolfgang

PY - 2013/6

Y1 - 2013/6

N2 - The reduction of structure sizes in microcontollers, environmental conditions or low supply voltages increase the susceptibility of embedded systems to soft errors. As a result, the employment of fault-detection and fault-tolerance measures is becoming a mandatory task even for moderately critical applications. Accordingly, software-based techniques have recently gained in popularity, and a multitude of approaches that differ in the number and frequency of tolerated errors as well as their associated overhead have been proposed. Using type-safe programming languages to isolate critical software components is very popular among those techniques. An automated application of fault-detection and fault-tolerance measures based on the type system of the programming language and static code analyses is possible. It facilitates an easy evaluation of the protection characteristics and costs as well as the migration of software to new hardware platforms with different failure rates. Transient faults, however, are not bound to the application code secured by the type system, but can also affect the correctness of the type system itself. Thereby, the type system might lose its ability to isolate critical components. As a consequence, it is essential to also protect the type system itself against soft errors. In this paper, we show how soft errors can affect the integrity of the type system. Furthermore, we provide means to secure it against these faults, thus preserving its isolating character. These measures can be applied selectively to achieve a suitable tradeoff between level of protection and resource consumption.

AB - The reduction of structure sizes in microcontollers, environmental conditions or low supply voltages increase the susceptibility of embedded systems to soft errors. As a result, the employment of fault-detection and fault-tolerance measures is becoming a mandatory task even for moderately critical applications. Accordingly, software-based techniques have recently gained in popularity, and a multitude of approaches that differ in the number and frequency of tolerated errors as well as their associated overhead have been proposed. Using type-safe programming languages to isolate critical software components is very popular among those techniques. An automated application of fault-detection and fault-tolerance measures based on the type system of the programming language and static code analyses is possible. It facilitates an easy evaluation of the protection characteristics and costs as well as the migration of software to new hardware platforms with different failure rates. Transient faults, however, are not bound to the application code secured by the type system, but can also affect the correctness of the type system itself. Thereby, the type system might lose its ability to isolate critical components. As a consequence, it is essential to also protect the type system itself against soft errors. In this paper, we show how soft errors can affect the integrity of the type system. Furthermore, we provide means to secure it against these faults, thus preserving its isolating character. These measures can be applied selectively to achieve a suitable tradeoff between level of protection and resource consumption.

KW - Embedded systems

KW - Java

KW - KESO

KW - Real-time systems

KW - Reliability

KW - RTSJ

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

U2 - 10.1145/2465554.2465571

DO - 10.1145/2465554.2465571

M3 - Conference contribution

AN - SCOPUS:84890503309

SN - 9781450320856

SP - 21

EP - 31

BT - LCTES '13: Proceedings of the 14th ACM SIGPLAN/SIGBED conference on Languages, compilers and tools for embedded systems

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

Y2 - 20 June 2013 through 21 June 2013

ER -