444 lines
39 KiB
BibTeX
444 lines
39 KiB
BibTeX
@article{aidemarkGOOFIGenericObjectOriented,
|
||
title = {{{GOOFI}} : {{Generic Object-Oriented Fault Injection Tool}}},
|
||
author = {Aidemark, Joakim and Vinter, Jonny and Folkesson, Peter and Karlsson, Johan},
|
||
date = {2001},
|
||
abstract = {In this paper, we present a new fault injection tool called GOOFI (Generic Object-Oriented Fault Injection). GOOFI is designed to be adaptable to various target systems and different fault injection techniques. The tool is highly portable between different host platforms since it relies on the Java programming language and a SQL compatible database. The current version of the tool supports pre-runtime Software Implemented Fault Injection and Scan-Chain Implemented Fault Injection.},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/3RK6XB92/Aidemark et al. - 2001 - GOOFI Generic Object-Oriented Fault Injection Tool.pdf}
|
||
}
|
||
|
||
@article{arlatFaultInjectionDependability1990,
|
||
title = {Fault Injection for Dependability Validation: A Methodology and Some Applications},
|
||
shorttitle = {Fault Injection for Dependability Validation},
|
||
author = {Arlat, J. and Aguera, M. and Amat, L. and Crouzet, Y. and Fabre, J.-C. and Laprie, J.-C. and Martins, E. and Powell, D.},
|
||
date = {1990-02},
|
||
journaltitle = {IEEE Transactions on Software Engineering},
|
||
shortjournal = {IIEEE Trans. Software Eng.},
|
||
volume = {16},
|
||
number = {2},
|
||
pages = {166--182},
|
||
issn = {00985589},
|
||
doi = {10.1109/32.44380},
|
||
url = {http://ieeexplore.ieee.org/document/44380/},
|
||
urldate = {2026-07-07},
|
||
abstract = {This paper addresses the problem of the dependability validation of fault-tolerant computing systems and more specifically the validation of the fault-tolerance mechanisms. The presented approach is based on the use of fault-injection at the physical level on a hardwarelsoftware prototype of the considered system. The place of this approach in a validation directed design process, as well as its place with respect to related works on fault-injection, is clearly identified. The major requirements and problems related to the development and application of a validation methodology based on fault injection are presented and discussed. Emphasis is put on the definition, analysis, and use of the experimental dependability measures that can be obtained. The proposed methodology has been implemented through the realization of a general pin-level fault injection tool (MESSALINE) and its usefulness is demonstrated by the application of MESSALINE to the experimental validation of two systems: 1) a subsystem of a centralized computerized inerlocking system for railway control applications and 2) a distributed system corresponding to the current implementation of the dependable communication system of the ESPRIT Delta-4 Project.},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/7J6HHXRR/Arlat et al. - 1990 - Fault injection for dependability validation a methodology and some applications.pdf}
|
||
}
|
||
|
||
@inproceedings{chenImprovingJavaVirtual2005,
|
||
title = {Improving Java Virtual Machine Reliability for Memory-Constrained Embedded Systems},
|
||
booktitle = {Proceedings of the 42nd Annual Conference on {{Design}} Automation - {{DAC}} '05},
|
||
author = {Chen, Guangyu and Kandemir, Mahmut},
|
||
date = {2005},
|
||
pages = {690},
|
||
publisher = {ACM Press},
|
||
location = {San Diego, California, USA},
|
||
doi = {10.1145/1065579.1065761},
|
||
url = {http://portal.acm.org/citation.cfm?doid=1065579.1065761},
|
||
urldate = {2026-03-26},
|
||
abstract = {Dual-execution/checkpointing based transient error tolerance techniques have been widely used in the high-end mission critical systems. These techniques, however, are not very attractive for cost-sensitive embedded systems because they require extra resources (e.g., large memory, special hardware, etc), and thus increase overall cost of the system. In this paper, we propose a transient error tolerant Java Virtual Machine (JVM) implementation for embedded systems. Our JVM uses dual-execution and checkpointing to detect and recover from transient errors. However, our technique does not require any special hardware support (except for the memory page protection mechanism, which is commonly available in modern embedded processors), and the memory space overhead it incurs is not excessive. Therefore, it is suitable for memory-constrained embedded systems. We implemented our approach and performed experiments with seven embedded Java applications.},
|
||
eventtitle = {The 42nd Annual Conference},
|
||
isbn = {978-1-59593-058-3},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/FKKICG9F/Chen and Kandemir - 2005 - Improving java virtual machine reliability for memory-constrained embedded systems.pdf}
|
||
}
|
||
|
||
@inproceedings{fidalgoUsingNEXUSCompliant2006,
|
||
title = {Using {{NEXUS}} Compliant Debuggers for Real Time Fault Injection on Microprocessors},
|
||
booktitle = {Proceedings of the 19th Annual Symposium on {{Integrated}} Circuits and Systems Design},
|
||
author = {Fidalgo, André and Gericota, Manuel and Alves, Gustavo and Ferreira, José},
|
||
date = {2006-08-28},
|
||
pages = {214--219},
|
||
publisher = {ACM},
|
||
location = {Ouro Preto MG Brazil},
|
||
doi = {10.1145/1150343.1150397},
|
||
url = {https://dl.acm.org/doi/10.1145/1150343.1150397},
|
||
urldate = {2026-07-06},
|
||
eventtitle = {{{SBCCI06}}: 19th {{Symposium}} on {{Integrated Circuits}} and {{System Design}}},
|
||
isbn = {978-1-59593-479-6},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/LDE6FJQF/Fidalgo et al. - 2006 - Using NEXUS compliant debuggers for real time fault injection on microprocessors.pdf}
|
||
}
|
||
|
||
@article{forinVitalCodedMicroprocessor1990,
|
||
title = {Vital {{Coded Microprocessor Principles}} and {{Application}} for {{Various Transit Systems}}},
|
||
author = {Forin, P.},
|
||
date = {1990-09},
|
||
journaltitle = {IFAC Proceedings Volumes},
|
||
shortjournal = {IFAC Proceedings Volumes},
|
||
volume = {23},
|
||
number = {2},
|
||
pages = {79--84},
|
||
issn = {14746670},
|
||
doi = {10.1016/S1474-6670(17)52653-1},
|
||
url = {https://linkinghub.elsevier.com/retrieve/pii/S1474667017526531},
|
||
urldate = {2026-03-30},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/77H4FFUQ/Forin - 1990 - Vital Coded Microprocessor Principles and Application for Various Transit Systems.pdf}
|
||
}
|
||
|
||
@inproceedings{goloubevaSofterrorDetectionUsing2003,
|
||
title = {Soft-Error Detection Using Control Flow Assertions},
|
||
booktitle = {Proceedings 18th {{IEEE Symposium}} on {{Defect}} and {{Fault Tolerance}} in {{VLSI Systems}}},
|
||
author = {Goloubeva, O. and Rebaudengo, M. and Sonza Reorda, M. and Violante, M.},
|
||
date = {2003},
|
||
pages = {581--588},
|
||
publisher = {IEEE},
|
||
location = {Boston, MA, USA},
|
||
doi = {10.1109/DFTVS.2003.1250158},
|
||
url = {https://ieeexplore.ieee.org/document/1250158/},
|
||
urldate = {2026-07-06},
|
||
abstract = {Over the last years, an increasing number of safety-critical tasks have been demanded to computer systems. In this paper, a software-based approach for developing safety-critical applications is analyzed. The technique is based on the introduction of additional executable assertions to check the correct execution of the program control flow. By applying the proposed technique, several benchmark applications have been hardened against transient errors. Fault Injection campaigns have been performed to evaluate the fault detection capability of the proposed technique in comparison with state-of-the-art alternative assertionbased methods. Experimental results show that the proposed approach is far more effective than the other considered techniques in terms of fault detection capability, at the cost of a limited increase in memory requirements and in performance overhead.},
|
||
eventtitle = {Proceedings. 18th {{IEEE International Symposium}} on {{Defect}} and {{Fault Tolerance}} in {{VLSI Systems}}},
|
||
isbn = {978-0-7695-2042-1},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/WI2QDM9X/Goloubeva et al. - 2003 - Soft-error detection using control flow assertions.pdf}
|
||
}
|
||
|
||
@article{hammingErrorDetectingError,
|
||
title = {Error Detecting and Error Correcting Codes},
|
||
author = {Hamming, Richard W},
|
||
date = {1950-04},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/AYGVTSAN/Hamming - 1950 - Error detecting and error correcting codes.pdf}
|
||
}
|
||
|
||
@article{hoffmannExperiencesSoftwarebasedSofterror2016,
|
||
title = {Experiences with Software-Based Soft-Error Mitigation Using {{AN}} Codes},
|
||
author = {Hoffmann, Martin and Ulbrich, Peter and Dietrich, Christian and Schirmeier, Horst and Lohmann, Daniel and Schröder-Preikschat, Wolfgang},
|
||
date = {2016-03},
|
||
journaltitle = {Software Quality Journal},
|
||
shortjournal = {Software Qual J},
|
||
volume = {24},
|
||
number = {1},
|
||
pages = {87--113},
|
||
issn = {0963-9314, 1573-1367},
|
||
doi = {10.1007/s11219-014-9260-4},
|
||
url = {http://link.springer.com/10.1007/s11219-014-9260-4},
|
||
urldate = {2026-07-06},
|
||
abstract = {Arithmetic error coding schemes are a well known and effective technique for soft error mitigation. Although the underlying coding theory is generally a complex area of mathematics, its practical implementation is comparatively simple in general. However, compliance with the theory can be lost easily while moving towards an actual implementation, which finally jeopardizes the aspired fault-tolerance characteristics and effectiveness. In this paper, we present our experiences and lessons learned from implementing arithmetic error coding schemes (AN codes) in the context of our Combined Redundancy fault-tolerance approach. We focus on the challenges and pitfalls in the transition from maths to machine code for a binary computer from a systems perspective. Our results show, that practical misconceptions (such as the use of prime numbers) and architecture-dependent implementation glitches occur at every stage of this transition. We identify typical pitfalls and describe practical measures to find and resolve them. This allowed us to eliminate all remaining silent data corruptions in the Combined Redundancy framework, which we validated by an extensive fault-injection campaign covering the entire fault space of 1-bit and 2-bit errors.},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/UU2JZ5HL/Hoffmann et al. - 2016 - Experiences with software-based soft-error mitigation using AN codes.pdf}
|
||
}
|
||
|
||
@inproceedings{hoffmannPractitionersGuideSoftwareBased2014,
|
||
title = {A {{Practitioner}}'s {{Guide}} to {{Software-Based Soft-Error Mitigation Using AN-Codes}}},
|
||
booktitle = {2014 {{IEEE}} 15th {{International Symposium}} on {{High-Assurance Systems Engineering}}},
|
||
author = {Hoffmann, Martin and Ulbrich, Peter and Dietrich, Christian and Schirmeier, Horst and Lohmann, Daniel and Schroder-Preikschat, Wolfgang},
|
||
date = {2014-01},
|
||
pages = {33--40},
|
||
publisher = {IEEE},
|
||
location = {Miami Beach, FL, USA},
|
||
doi = {10.1109/HASE.2014.14},
|
||
url = {http://ieeexplore.ieee.org/document/6754585/},
|
||
urldate = {2026-01-05},
|
||
abstract = {Arithmetic error coding schemes (AN codes1) are a well known and effective technique for soft error mitigation. Although coding theory being a rich area of mathematics, their implementation seems to be fairly easy. However, compliance with the theory can be lost easily while moving towards an actual implementation – finally jeopardizing the aspired fault-tolerance characteristics. In this paper, we present our experiences and lessons learned from implementing AN codes in the CoRed dependable voter. We focus on the challenges and pitfalls in the transition from maths to machine code for a binary computer from a systems perspective. Our results show, that practical misconceptions (such as the use of prime numbers) and architecturedependent implementation glitches occur at every stage of this transition. We identify typical pitfalls and describe practical measures to find and resolve them. Our measures eliminate all remaining SDCs in the CoRed voter, which is validated by an extensive fault-injection campaign that covers 100 percent of the fault space for 1-bit and 2-bit errors.},
|
||
eventtitle = {2014 {{IEEE}} 15th {{International Symposium}} on {{High-Assurance Systems Engineering}} ({{HASE}})},
|
||
isbn = {978-1-4799-3466-9 978-1-4799-3465-2},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/CY3ULLCA/Hoffmann et al. - 2014 - A Practitioner's Guide to Software-Based Soft-Error Mitigation Using AN-Codes.pdf}
|
||
}
|
||
|
||
@inproceedings{kuvaiskiiAmpampx0394EncodingPracticalEncoded2015,
|
||
title = {Delta-{{Encoding}}: {{Practical Encoded Processing}}},
|
||
shorttitle = {\&Amp;\#x0394;-{{Encoding}}},
|
||
booktitle = {2015 45th {{Annual IEEE}}/{{IFIP International Conference}} on {{Dependable Systems}} and {{Networks}}},
|
||
author = {Kuvaiskii, Dmitrii and Fetzer, Christof},
|
||
date = {2015-06},
|
||
pages = {13--24},
|
||
publisher = {IEEE},
|
||
location = {Rio de Janeiro, Brazil},
|
||
doi = {10.1109/DSN.2015.20},
|
||
url = {https://ieeexplore.ieee.org/document/7266834},
|
||
urldate = {2026-07-06},
|
||
abstract = {Transient and permanent errors in memory and CPUs occur with alarming frequency. Although most of these errors are masked at the hardware level or result in crashes, a non-negligible number of them leads to Silent Data Corruptions (SDCs), i.e., incorrect results of computations. Safety-critical programs require a very high level of confidence that such faults are detected and not propagated to the outside. Unfortunately, state-of-the-art fault detection techniques generally assume a limited Single Event Upset fault model, concentrating only on transient faults.},
|
||
eventtitle = {2015 45th {{Annual IEEE}}/{{IFIP International Conference}} on {{Dependable Systems}} and {{Networks}} ({{DSN}})},
|
||
isbn = {978-1-4799-8629-3},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/XBMRFFTE/Kuvaiskii and Fetzer - 2015 - Delta-Encoding Practical Encoded Processing.pdf}
|
||
}
|
||
|
||
@thesis{munkSoftwareFaultToleranceMechanism,
|
||
title = {A Software Fault-Tolerance Mechanism for Mixed-Critical Real-Time Applications on Consumer-Grade Many-Core Processors},
|
||
author = {Munk, Peter},
|
||
date = {2016-07},
|
||
langid = {ngerman},
|
||
file = {/home/christoph/Notes/Zotero/storage/8QKA739L/Munk - 2016 - A Software Fault-Tolerance Mechanism for Mixed-Critical Real-Time Applications on Consumer-Grade Man.pdf}
|
||
}
|
||
|
||
@article{polednaReplicaDeterminismDistributed1994,
|
||
title = {Replica Determinism in Distributed Real-Time Systems: {{A}} Brief Survey},
|
||
shorttitle = {Replica Determinism in Distributed Real-Time Systems},
|
||
author = {Poledna, Stefan},
|
||
date = {1994-05},
|
||
journaltitle = {Real-Time Systems},
|
||
shortjournal = {Real-Time Syst},
|
||
volume = {6},
|
||
number = {3},
|
||
pages = {289--316},
|
||
issn = {0922-6443, 1573-1383},
|
||
doi = {10.1007/BF01088629},
|
||
url = {http://link.springer.com/10.1007/BF01088629},
|
||
urldate = {2026-03-26},
|
||
abstract = {Replication of entities is a convenient technique to achieve fault-tolerance. The problem of replica determinism thereby is to assure, that replicated entities show consistent behavior in the absence of failures. Possible sources for replica non-determinism as well as basic requirements and strategies to enforce replica determinism axe presented. The problem of replica determinism enforcement under real-time constraints is surveyed in the context of the communication problem for distributed systems. Furthermore the close interdependence between replica determinism on the one side and synchronization strategies, handling of failures and redundancy preservation on the other side is reviewed. The impact of synchronous or asynchronous approaches on replication strategies is also discussed.},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/DB8GU2TK/Poledna - 1994 - Replica determinism in distributed real-time systems A brief survey.pdf}
|
||
}
|
||
|
||
@article{raabSafeSoftwareProcessing,
|
||
title = {Safe Software Processing by Concurrent Execution in a Real-Time Operating System},
|
||
author = {Raab, Peter and Kramer, Stefan and Mottok, Jurgen and Meier, Hans and Racek, Stanislav},
|
||
date = {2011-09},
|
||
abstract = {The requirements for safety-related software systems increases rapidly. To detect arbitrary hardware faults, there are applicable coding mechanism, that add redundancy to the software. In this way it is possible to replace conventional multi-channel hardware and so reduce costs. Arithmetic codes are one possibility of coded processing and are used in this approach. A further approach to increase fault tolerance is the multiple execution of certain critical parts of software. This kind of time redundancy is easily realized by the parallel processing in an operating system. Faults in the program flow can be monitored. No special compilers, that insert additional generated code into the existing program, are required. The usage of multi-core processors would further increase the performance of such multi-channel software systems. In this paper we present the approach of program flow monitoring combined with coded processing, which is encapsulated in a library of coded data types. The program flow monitoring is indirectly realized by means of an operating system.},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/MJAVLTNB/Raab et al. - 2011 - Safe software processing by concurrent execution in a real-time operating system.pdf}
|
||
}
|
||
|
||
@inproceedings{rebaudengoSofterrorDetectionSoftware1999,
|
||
title = {Soft-Error Detection through Software Fault-Tolerance Techniques},
|
||
booktitle = {Proceedings 1999 {{IEEE International Symposium}} on {{Defect}} and {{Fault Tolerance}} in {{VLSI Systems}} ({{EFT}}'99)},
|
||
author = {Rebaudengo, M. and Sonza Reorda, M. and Torchiano, M. and Violante, M.},
|
||
date = {1999},
|
||
pages = {210--218},
|
||
publisher = {IEEE Comput. Soc},
|
||
location = {Albuquerque, NM, USA},
|
||
doi = {10.1109/DFTVS.1999.802887},
|
||
url = {http://ieeexplore.ieee.org/document/802887/},
|
||
urldate = {2026-07-06},
|
||
abstract = {The paper describes a systematic approach for automatically introducing data and code redundancy into an existing program written using a high-level language. The transformations aim at making the program able to detect most of the soft-errors affecting data and code, independently of the Error Detection Mechanisms (EDMs) possibly implemented by the hardware. Since the transformations can be automatically applied as a pre-compilation phase, the programmer is freed from the cost and responsibility of introducing suitable EDMs in its code. Preliminary experimental results are reported, showing the fault coverage obtained by the method, as well as some figures concerning the slow-down and code size increase it causes.},
|
||
eventtitle = {1999 {{IEEE International Symposium}} on {{Defect}} and {{Fault Tolerance}} in {{VLSI Systems}}},
|
||
isbn = {978-0-7695-0325-7},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/HFQUUT6L/Rebaudengo et al. - 1999 - Soft-error detection through software fault-tolerance techniques.pdf}
|
||
}
|
||
|
||
@incollection{schiffelANBANBDmemEncodingDetecting2010,
|
||
title = {{{ANB-}} and {{ANBDmem-Encoding}}: {{Detecting Hardware Errors}} in {{Software}}},
|
||
shorttitle = {{{ANB-}} and {{ANBDmem-Encoding}}},
|
||
booktitle = {Computer {{Safety}}, {{Reliability}}, and {{Security}}},
|
||
author = {Schiffel, Ute and Schmitt, André and Süßkraut, Martin and Fetzer, Christof},
|
||
editor = {Schoitsch, Erwin},
|
||
editora = {Hutchison, David and Kanade, Takeo and Kittler, Josef and Kleinberg, Jon M. and Mattern, Friedemann and Mitchell, John C. and Naor, Moni and Nierstrasz, Oscar and Pandu Rangan, C. and Steffen, Bernhard and Sudan, Madhu and Terzopoulos, Demetri and Tygar, Doug and Vardi, Moshe Y. and Weikum, Gerhard},
|
||
editoratype = {redactor},
|
||
date = {2010},
|
||
volume = {6351},
|
||
pages = {169--182},
|
||
publisher = {Springer Berlin Heidelberg},
|
||
location = {Berlin, Heidelberg},
|
||
doi = {10.1007/978-3-642-15651-9_13},
|
||
url = {http://link.springer.com/10.1007/978-3-642-15651-9_13},
|
||
urldate = {2026-03-29},
|
||
abstract = {It is expected that commodity hardware is becoming less reliable because of the continuously decreasing feature sizes of integrated circuits. Nevertheless, more and more commodity hardware with insufficient error detection is used in critical applications. One possible solution is to detect hardware errors in software using arithmetic AN-codes. These codes detect hardware errors independent of the actual failure modes of the underlying hardware. However, measurements have shown that AN-codes still exhibit large rates of undetected silent data corruptions (SDC). These high rates of undetected SDCs are caused by the insufficient protection of control and data flow through AN-codes. In contrast, ANB- and ANBD-codes promise much higher error detection rates because they also detect errors in control and data flow. We present our encoding compiler that automatically applies either an AN-, ANBor ANBD-code to an application. Our error injections show that AN-, ANB-, and ANBD-codes successfully detect errors and more important that indeed ANB- and ANBD-codes reduce the SDC rate more effectively than AN-codes. The difference between ANBD- and ANB-codes is also visible but less pronounced.},
|
||
isbn = {978-3-642-15650-2 978-3-642-15651-9},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/VU7Y6B54/Schiffel et al. - 2010 - ANB- and ANBDmem-Encoding Detecting Hardware Errors in Software.pdf}
|
||
}
|
||
|
||
@thesis{schiffelHardwareErrorDetection2011,
|
||
type = {phdthesis},
|
||
title = {Hardware {{Error Detection Using AN-Codes}}},
|
||
author = {Schiffel, Ute},
|
||
date = {2011},
|
||
institution = {Technical University of Dresden},
|
||
location = {Dresden},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/7BXMSTFW/Hardware_Error_Detection_Using_AN_Codes.pdf}
|
||
}
|
||
|
||
@incollection{schirmeierDependabilityAspectsConfigurable2021,
|
||
title = {Dependability {{Aspects}} in {{Configurable Embedded Operating Systems}}},
|
||
booktitle = {Dependable {{Embedded Systems}}},
|
||
author = {Schirmeier, Horst and Borchert, Christoph and Hoffmann, Martin and Dietrich, Christian and Martens, Arthur and Kapitza, Rüdiger and Lohmann, Daniel and Spinczyk, Olaf},
|
||
editor = {Henkel, Jörg and Dutt, Nikil},
|
||
date = {2021},
|
||
pages = {85--116},
|
||
publisher = {Springer International Publishing},
|
||
location = {Cham},
|
||
doi = {10.1007/978-3-030-52017-5_4},
|
||
url = {http://link.springer.com/10.1007/978-3-030-52017-5_4},
|
||
urldate = {2026-07-06},
|
||
abstract = {Abstract As all conceptual layers in the software stack depend on the operating system (OS) to reliably provide resource-management services and isolation, it can be considered the “reliable computing base” that must be hardened for correct operation under fault models such as transient hardware faults in the memory hierarchy. In this chapter, we approach the problem of system-software hardening in three complementary scenarios. (1) We address the following research question: Where do the general reliability limits of static system-software stacks lie, if designed from scratch with reliability as a first-class design goal? In order to reduce the proverbial “attack surface” as far as possible, we harness static application knowledge from an AUTOSAR-compliant task set, and protect the whole OS kernel with AN-encoding. This static approach yields an extremely reliable software system, but is constrained to specific application domains. (2) We investigate how reliable a dynamic COTS embedded OS can become if hardened with programming-language and compiler-based fault-tolerance techniques. We show that aspect-oriented programming is an appropriate means to encapsulate generic software-implemented hardware fault tolerance mechanisms that can be application-specifically applied to a selection of OS components. (3) We examine how system-software stacks can survive even more adverse fault models like whole-system outages, using emerging persistent memory (PM) technology as a vehicle for state conservation. Our findings include that software transactional memory facilitates maintaining consistent state within PM and allows fast recovery.},
|
||
isbn = {978-3-030-52016-8 978-3-030-52017-5},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/WAVR4R62/Schirmeier et al. - 2021 - Dependability Aspects in Configurable Embedded Operating Systems.pdf}
|
||
}
|
||
|
||
@thesis{schirmeierEfficientFaultInjectionbasedAssessment,
|
||
type = {phdthesis},
|
||
title = {Efficient {{Fault-Injection-based Assessment}} of {{Software-Implemented Hardware Fault Tolerance}}},
|
||
author = {Schirmeier, Horst},
|
||
date = {2016},
|
||
institution = {Technical University of Dortmund},
|
||
location = {Dortmund},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/MIBRJ5DT/Schirmeier - Efficient Fault-Injection-based Assessment of Software-Implemented Hardware Fault Tolerance.pdf}
|
||
}
|
||
|
||
@inproceedings{schirmeierFAILOpenVersatile2015,
|
||
title = {{{FAIL}}*: {{An Open}} and {{Versatile Fault-Injection Framework}} for the {{Assessment}} of {{Software-Implemented Hardware Fault Tolerance}}},
|
||
shorttitle = {{{FAIL}}*},
|
||
booktitle = {2015 11th {{European Dependable Computing Conference}} ({{EDCC}})},
|
||
author = {Schirmeier, Horst and Hoffmann, Martin and Dietrich, Christian and Lenz, Michael and Lohmann, Daniel and Spinczyk, Olaf},
|
||
date = {2015-09},
|
||
pages = {245--255},
|
||
publisher = {IEEE},
|
||
location = {Paris, France},
|
||
doi = {10.1109/EDCC.2015.28},
|
||
url = {https://ieeexplore.ieee.org/document/7371972/},
|
||
urldate = {2026-03-29},
|
||
abstract = {Due to voltage and structure shrinking, the influence of radiation on a circuit’s operation increases, resulting in future hardware designs exhibiting much higher rates of soft errors. Software developers have to cope with these effects to ensure functional safety. However, software-based hardware fault tolerance is a holistic property that is tricky to achieve in practice, potentially impaired by every single design decision. We present FAIL*, an open and versatile architecture-level fault-injection (FI) framework for the continuous assessment and quantification of fault tolerance in an iterative software development process. FAIL* supplies the developer with reusable and composable FI campaigns, advanced pre- and post-processing analyses to easily identify sensitive spots in the software, wellabstracted back-end implementations for several hardware and simulator platforms, and scalability of FI campaigns by providing massive parallelization. We describe FAIL*, its application to the development process of safety-critical software, and the lessons learned from a real-world example.},
|
||
eventtitle = {2015 11th {{European Dependable Computing Conference}} ({{EDCC}})},
|
||
isbn = {978-1-4673-9289-1},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/DVEUWLJJ/Schirmeier et al. - 2015 - FAIL An Open and Versatile Fault-Injection Framework for the Assessment of Software-Implemented Ha.pdf}
|
||
}
|
||
|
||
@article{schirmeierFAILVersatileFaultInjection2012,
|
||
title = {{{FAIL}}*: {{Towards}} a {{Versatile Fault-Injection Experiment Framework}}},
|
||
author = {Schirmeier, Horst and Hoffmann, Martin and Kapitza, Rüdiger and Lohmann, Daniel and Spinczyk, Olaf},
|
||
date = {2012-01},
|
||
abstract = {Many years of research on dependable, faulttolerant software systems yielded many tool implementations for vulnerability analysis and experimental validation of resilience measures. We identify two disjoint classes of fault-injection (FI) experiment tools in the field, and argue that both are plagued by inherent deficiencies, such as insufficient target state access, little or no means to switch to another target system, and non-reusable experiment code.},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/G9SATNLR/Schirmeier et al. - FAIL Towards a Versatile Fault-Injection Experiment Framework.pdf}
|
||
}
|
||
|
||
@article{schusterDemystifyingSoftErrorMitigation2017,
|
||
title = {Demystifying {{Soft-Error Mitigation}} by {{Control-Flow Checking}} -- {{A New Perspective}} on Its {{Effectiveness}}},
|
||
author = {Schuster, Simon and Ulbrich, Peter and Stilkerich, Isabella and Dietrich, Christian and SchröDer-Preikschat, Wolfgang},
|
||
date = {2017-10-31},
|
||
journaltitle = {ACM Transactions on Embedded Computing Systems},
|
||
shortjournal = {ACM Trans. Embed. Comput. Syst.},
|
||
volume = {16},
|
||
pages = {1--19},
|
||
issn = {1539-9087, 1558-3465},
|
||
doi = {10.1145/3126503},
|
||
url = {https://dl.acm.org/doi/10.1145/3126503},
|
||
urldate = {2026-07-06},
|
||
abstract = {Soft errors are a challenging and urging problem in the domain of safety-critical embedded systems. For decades, checking schemes have been investigated and improved to mitigate soft-error effects for the class of control-flow faults, with current industrial standards strongly recommending their use. However, reality looks different: Taking a systems perspective, we implemented four representative Control-Flow Checking (CFC) schemes and put them through their paces in 396 fault-injection campaigns. In contrast to previous work, which typically relied on probability-based vulnerability metrics, we accounted for the influence of memory and time overheads on the fault-space dimensions and applied those in full-scan fault injections. This change in procedure alone severely degraded the perceived effectiveness of CFC. In addition, we expanded the perspective to data-flow faults and their influence on the overall susceptibility, an aspect that so far has been largely ignored. Our results suggest that, without accompanying measures, any improvement regarding control-flow faults is dominated by the increase in data faults caused by the increased attack surface in terms of memory and runtime overhead. Moreover, CFC performance less depended on the detection capabilities than on general aspects of the concrete binary compilation and execution. In conclusion, incorporating CFC is not as straightforward as often assumed and the vulnerability of systems with hardened control-flow may in many cases even be increased by the schemes themselves.},
|
||
issue = {5s},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/BLKUCBAD/Schuster et al. - 2017 - Demystifying Soft-Error Mitigation by Control-Flow Checking -- A New Perspective on its Effectivenes.pdf}
|
||
}
|
||
|
||
@inproceedings{skarinGOOFI2ToolExperimental2010,
|
||
title = {{{GOOFI-2}}: {{A}} Tool for Experimental Dependability Assessment},
|
||
shorttitle = {{{GOOFI-2}}},
|
||
booktitle = {2010 {{IEEE}}/{{IFIP International Conference}} on {{Dependable Systems}} \& {{Networks}} ({{DSN}})},
|
||
author = {Skarin, Daniel and Barbosa, Raul and Karlsson, Johan},
|
||
date = {2010-06},
|
||
pages = {557--562},
|
||
publisher = {IEEE},
|
||
location = {Chicago, IL},
|
||
doi = {10.1109/DSN.2010.5544265},
|
||
url = {http://ieeexplore.ieee.org/document/5544265/},
|
||
urldate = {2026-07-06},
|
||
abstract = {This paper presentsGOOFI-2, a comprehensive fault in jection tool for experimental dependability assessment of embedded systems. The tool includes a large number of ex tensions and improvements over its predecessor, GOOF!. These include support for three widely used fault injection techniques, two target processors, and a variety of new features for storing, disseminating and analyzing experi mental data. We report on our experiences and lessons learned from the use and development ofGOOFI-2. In par ticular, we compare and discuss properties of three fault injection techniques: Nexus-based, exception-based and instrumentation-based injection. The comparison relies on several sets of experiments with two target processors, Freescale's MPC565 and MPC5554.},
|
||
eventtitle = {2010 {{IEEE}}/{{IFIP International Conference}} on {{Dependable Systems}} \& {{Networks}} ({{DSN}})},
|
||
isbn = {978-1-4244-7500-1 978-1-4244-7501-8},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/2HMSUPZM/Skarin et al. - 2010 - GOOFI-2 A tool for experimental dependability assessment.pdf}
|
||
}
|
||
|
||
@book{slettenWebAssemblyDefinitiveGuide2021,
|
||
title = {{{WebAssembly}}: The Definitive Guide: Safe, Fast, and Portable Code},
|
||
shorttitle = {{{WebAssembly}}},
|
||
author = {Sletten, Brian},
|
||
date = {2021},
|
||
edition = {First edition},
|
||
publisher = {O'Reilly Media},
|
||
location = {Sebastopol, CA},
|
||
abstract = {"WebAssembly: The Definitive Guide is a thorough and accessible introduction to one of the most transformative technologies hitting our industry. What started as a way to use languages other than JavaScript in the browser has evolved into a comprehensive path toward portability, performance, increased security, and greater code reuse across an impressive collection of deployment targets. Author Brian Sletten introduces elements of this technology incrementally while building to several concrete, code-driven examples of practical, cutting-edge WebAssembly uses. Whether you work with enterprise software or embedded systems, or in entertainment, scientific computing, or startup environments, you'll learn how WebAssembly can have a positive impact on the way you develop software." -- Back cover},
|
||
isbn = {978-1-4920-8984-1},
|
||
pagetotal = {317},
|
||
keywords = {Application software,Assembly languages (Electronic computers),Computer programs,Development,Développement,Développement Logiciels,Guides et manuels,Handbook,Handbooks and manuals,Internet programming,Langage assembleur (Langage de programmation),Logiciels d'application,Programmation Internet,Sites Web,Web site development},
|
||
file = {/home/christoph/Notes/Zotero/storage/82VVGKJV/Sletten - 2021 - WebAssembly the definitive guide safe, fast, and portable code.pdf}
|
||
}
|
||
|
||
@article{soloukiDependabilityEmbeddedSystems2024,
|
||
title = {Dependability in {{Embedded Systems}}: {{A Survey}} of {{Fault Tolerance Methods}} and {{Software-Based Mitigation Techniques}}},
|
||
shorttitle = {Dependability in {{Embedded Systems}}},
|
||
author = {Solouki, Mohammadreza Amel and Angizi, Shaahin and Violante, Massimo},
|
||
date = {2024},
|
||
journaltitle = {IEEE Access},
|
||
shortjournal = {IEEE Access},
|
||
volume = {12},
|
||
pages = {180939--180967},
|
||
issn = {2169-3536},
|
||
doi = {10.1109/ACCESS.2024.3509633},
|
||
url = {https://ieeexplore.ieee.org/document/10772080/},
|
||
urldate = {2026-03-26},
|
||
abstract = {Fault tolerance is a critical aspect of modern computing systems, ensuring correct functionality in the presence of faults. This paper presents a comprehensive survey of fault tolerance methods and mitigation techniques in embedded systems, with a focus on both software and hardware faults. Emphasis is placed on real-time embedded systems, considering their resource constraints and the increasing interconnectivity of computing systems in commercial and industrial applications. The survey covers various fault tolerance methods, including hardware, software, and hybrid redundancy. Particular attention is given to software faults, acknowledging their significance as a leading cause of system failures, while also addressing hardware faults and their mitigation. Moreover, the paper explores the challenges posed by soft errors in modern computing systems. The survey concludes by emphasizing the need for continued research and development in fault tolerance methods, specifically in the context of real-time embedded systems, and highlights the potential for extending fault tolerance approaches to diverse computing environments.},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/7I9EXB4N/Solouki et al. - 2024 - Dependability in Embedded Systems A Survey of Fault Tolerance Methods and Software-Based Mitigation.pdf}
|
||
}
|
||
|
||
@inproceedings{ulbrichEliminatingSinglePoints2012,
|
||
title = {Eliminating {{Single Points}} of {{Failure}} in {{Software-Based Redundancy}}},
|
||
booktitle = {2012 {{Ninth European Dependable Computing Conference}}},
|
||
author = {Ulbrich, P. and Hoffmann, M. and Kapitza, R. and Lohmann, D. and Schroder-Preikschat, W. and Schmid, R.},
|
||
date = {2012-05},
|
||
pages = {49--60},
|
||
publisher = {IEEE},
|
||
location = {Sibiu},
|
||
doi = {10.1109/EDCC.2012.21},
|
||
url = {http://ieeexplore.ieee.org/document/6214760/},
|
||
urldate = {2026-01-07},
|
||
eventtitle = {2012 {{Ninth European Dependable Computing Conference}} ({{EDCC}})},
|
||
isbn = {978-1-4673-0938-7 978-0-7695-4671-1},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/8QZAMSR7/Ulbrich et al. - 2012 - Eliminating Single Points of Failure in Software-Based Redundancy.pdf}
|
||
}
|
||
|
||
@incollection{wapplerSoftwareEncodedProcessing2007,
|
||
title = {Software {{Encoded Processing}}: {{Building Dependable Systems}} with {{Commodity Hardware}}},
|
||
shorttitle = {Software {{Encoded Processing}}},
|
||
booktitle = {Computer {{Safety}}, {{Reliability}}, and {{Security}}},
|
||
author = {Wappler, Ute and Fetzer, Christof},
|
||
editor = {Saglietti, Francesca and Oster, Norbert},
|
||
editora = {Hutchison, David and Kanade, Takeo and Kittler, Josef and Kleinberg, Jon M. and Mattern, Friedemann and Mitchell, John C. and Naor, Moni and Nierstrasz, Oscar and Pandu Rangan, C. and Steffen, Bernhard and Sudan, Madhu and Terzopoulos, Demetri and Tygar, Doug and Vardi, Moshe Y. and Weikum, Gerhard},
|
||
editoratype = {redactor},
|
||
date = {2007},
|
||
volume = {4680},
|
||
pages = {356--369},
|
||
publisher = {Springer Berlin Heidelberg},
|
||
location = {Berlin, Heidelberg},
|
||
doi = {10.1007/978-3-540-75101-4_34},
|
||
url = {http://link.springer.com/10.1007/978-3-540-75101-4_34},
|
||
urldate = {2026-03-26},
|
||
abstract = {In future, the decreasing feature size and the reduced power supply will make it much more difficult to built reliable microprocessors. Economic pressure will most likely result in the reliability of microprocessors being tuned for the commodity market. In the dependability domain we expect the continued spreading of mixed-mode computing systems, i.e., systems that execute both critical and non-critical functionality. To permit the efficient execution of non-critical applications and the correct execution of critical applications, we introduce the concept of Software Encoded Processing (SEP). SEP enforces a crash failure semantics of the underlying CPU. It does not require the source code of encoded programs and provides probabilistic guarantees. To achieve this, arithmetic codes and signatures are used to detect corrupted data and faulty executions of programs.},
|
||
isbn = {978-3-540-75100-7 978-3-540-75101-4},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/VQT3AEQF/Wappler and Fetzer - 2007 - Software Encoded Processing Building Dependable Systems with Commodity Hardware.pdf}
|
||
}
|
||
|
||
@misc{wasm1spec,
|
||
title = {{{WebAssembly}} 1.0 {{Specification}}},
|
||
author = {{WebAssembly Community Group} and Rossberg, Andreas},
|
||
date = {2019-07-20},
|
||
url = {https://webassembly.github.io/spec/versions/core/WebAssembly-1.0.pdf},
|
||
urldate = {2026-07-01},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/WQV9G6TQ/WebAssembly Community Group and Rossberg - 2019 - WebAssembly 1.0 Specification.pdf}
|
||
}
|
||
|
||
@misc{wasm2spec,
|
||
title = {{{WebAssembly}} 2.0 {{Specification}}},
|
||
author = {{WebAssembly Community Group} and Rossberg, Andreas},
|
||
date = {2025-09-16},
|
||
url = {https://webassembly.github.io/spec/versions/core/WebAssembly-2.0.pdf},
|
||
urldate = {2026-07-01},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/DKNDNCPF/WebAssembly Community Group and Rossberg - 2025 - WebAssembly 2.0 Specification.pdf}
|
||
}
|
||
|
||
@misc{wasm3spec,
|
||
title = {{{WebAssembly}} 3.0 {{Specification}} ({{Draft}})},
|
||
author = {{WebAssembly Community Group} and Rossberg, Andreas},
|
||
date = {2026-06-25},
|
||
url = {https://webassembly.github.io/spec/core/_download/WebAssembly.pdf},
|
||
urldate = {2026-07-01},
|
||
langid = {english},
|
||
file = {/home/christoph/Notes/Zotero/storage/8YB9FEXY/WebAssembly Community Group and Rossberg - 2026 - WebAssembly 3.0 Specification (Draft).pdf}
|
||
}
|