Date of this Version
Embedded systems are becoming increasingly ubiquitous, controlling a wide variety of popular and safety-critical devices. Testing is the most commonly used method for validating software systems, and effective testing techniques could be helpful for improving the dependability of these systems. However, there are challenges involved in developing such techniques. Embedded systems consist of layers of software – application layers utilize services provided by underlying system service and hardware support layers. A typical embedded application consists of multiple user tasks. Interactions between application layers and lower layers, and interactions between the various user tasks that are initiated by the application layer, can be a source of system failures in fielded applications. The “oracle problem” is also a challenging problem in many testing domains, but with embedded systems it can be particularly difficult. Embedded systems employing multiple tasks can have non-deterministic output, which complicates the determination of expected outputs for given inputs, and thus, complicates oracle automation.
There are many different classes of real-time embedded systems. For example, hard real-time embedded systems have strict temporal requirements, and include safety critical systems such as those found in avionics and automotive systems. Soft real-time embedded systems, in contrast, occur in a wide range of popular but less safety-critical systems such as consumer electronic devices, and tend not to have such rigorous temporal constraints. In this work, we focus on the latter class of systems.
In this thesis we present an approach for testing soft real-time embedded systems, intended specifically to help developers of soft real-time embedded system applications detect non-temporal faults. Our approach consists, first, of two testing techniques. Our first technique uses dataflow analysis to distinguish points of interaction between specific layers in embedded systems and between individual software components within those layers. Our second technique extends the first to track interactions between user tasks; these are sources of concurrency and other faults common in such systems. We present results of an empirical study that shows that these techniques can be effective. A second aspect of our approach addresses the oracle problem, and the need to provide observability of system behavior sufficient to allow engineers to detect failures. We present a family of property-based oracles that use instrumentation to record various aspects of execution behavior and compare observed behavior to certain intended system properties that can be derived through program analysis. We focus on several important non-temporal attributes of system behavior; in particular, attributes related to proper uses of synchronization primitives and other mechanisms important to managing cooperation and concurrency among tasks (e.g., semaphores, message passing protocols, and critical sections). An empirical study of this oracle approach shows that it can be effective.
Advisors: Gregg Rothermel and Witty Srisa-an