Jörg Behrend

Semiformal verification of temporal properties in automotive hardware dependent software

The verification of embedded software has become an important subject over the last years. This work presents a new semiformal verification approach called SofTPaDS. It combines assertion-based and symbolic simulation approaches for the verification of embedded software with hardware dependencies. SofTPaDS shows to be more efficient than the software model checkers in order to trace deep state spaces and improves the state coverage relative to a simulation-based verification tool. We have successfully applied our approach to an industrial automotive embedded software.

Scalable hybrid verification for embedded software

The verification of embedded software has become an important subject over the last years. However, neither standalone verification approaches, like simulation-based or formal verification, nor state-of-the-art hybrid/semiformal verification approaches are able to verify large and complex embedded software with hardware dependencies. This work presents a new scalable and extendable hybrid verification approach for the verification of temporal properties in embedded software with hardware dependencies using for the first time a new mixed bottom-up/top-down algorithm. Therefore, new algorithms and methodologies like static parameter assignment and counterexample guided simulation are proposed in order to combine simulation-based and formal verification in a new way. We have successfully applied this hybrid approach to embedded software applications: Motorolas Powerstone Benchmark suite and a complex industrial embedded automotive software. The results show that our approach scales better than stand-alone software model checkers to reach deep state spaces. The whole approach is best suited for fast falsification.

Scalable and Optimized Hybrid Verification of Embedded Software

The verification of embedded software has become an important subject over the last years. However, neither standalone verification approaches, like simulation-based/formal verification, nor state-of-the-art semiformal verification approaches are able to verify large and complex embedded software with or without hardware dependencies. This work presents a scalable hybrid verification approach for the verification of embedded software using a semiformal algorithm optimized with static parameter assignment (SPA). These algorithms and methodologies like SPA and counterexample guided simulation are used to combine simulation-based and formal verification in a new way. SPA offers a method to interact between dynamic and static verification approaches based on an automated ranking determination of possible function parameters according to the impact on the model size. Furthermore, SPA inserts initialization code for specific function parameters into the source code under test and supports model building and optimization algorithms to reduce the state space. We have successfully applied this optimized hybrid verification methodology to embedded software applications: Motorola’s Powerstone Benchmark suite and a complex automotive industrial embedded software. The results show that our approach scales better than standalone software model checkers to reach deep state spaces.

Object-Oriented Message-Passing in Heterogeneous Environments

Heterogeneous parallel systems integrate machines with different architectural characteristics, such as endianess and word size. To use message-passing in these environments, the data must be translated by the communication layer. Message-passing standards like the Message Passing Interface (MPI) require the user to specify the type of the data sent, such that the communication layer can effect the necessary conversions. We present an object-oriented message-passing library for C++, TPO++, which is capable to communicate in heterogeneous environments. Its functionality includes the MPI 1.2 standard, but it allows the user to communicate any data like objects or Standard Template Library (STL) containers in a type-safe way. It does not require the user to build a type representation explicitly. We compare the performance of heterogeneous TPO++ with Boost.MPI and the C interface of OpenMPI. Our findings are that heterogeneous communication in TPO++ is possible with a very small overhead in latency compared to pure MPI. The performance of TPO++ is considerably better than that of other object-oriented communication libraries.