In the first part of this series about software interfaces and contracts "Contract-based software development with Franca" we explained why the modelling of software interfaces plays an important role when designing the overall architecture of a software system.
With Franca IDL you can specify your service interfaces what already ensures the consistency between the model (the interface) at design time and the generated code (the implementation) at build time. Furthermore you can describe the dynamic behavior of client/server interactions by using the Franca contract feature.
From the interface validation point of view, this leads to two major questions:
How to check if the dynamic behavior of your interfaces is valid at run-time?
How to validate if interfaces are really invoked in the intended order, as specified in the contract?
This can be achieved with the system analysis tool EB solys, which has a built-in support for Franca and Franca Contracts. In this article I will give a short overview regarding the architecture of EB solys and its main capabilities.
The fundamental purpose of EB solys is to identify and localize functional and non-functional defects and shortcomings in highly complex software systems, fast and easy.
Current trends in the embedded software industry mean that developing projects has become an increasingly complex task. For instance, automotive software systems are moving into the direction of service-oriented architecture on distributed systems over multiple ECUs (electronic control units) and devices.
Observable functionality for the driver will then doubtlessly be implemented as a distributed software stack, which is cross-cutting several layers, nodes and technologies by multiple suppliers. Major coordination efforts are therefore required in order to test and guarantee the quality and robustness of the software system overall.
With EB solys, Elektrobit has developed a tool for highly complex development projects, which supports hot spot analysis and process optimization not only in individual components, but at a higher level in the system structure overall.
The diagram below shows the basic eco-system of the EB solys framework, that is composed of two building blocks: a data collector running on the target device and the analysis tool running on a host machine.
The target agent is a plugin-driven monitoring service for collecting arbitrary run-time data, running on the device which should be observed. The framework and some of its plugins are open source.
The plugins can be generally grouped into following types:
After collecting the data on the target device the focus on host side is on visualizing, aggregating and primarily correlating those data and operating states. Because often, errors and anomalies can only be detected when the data from different sources are set in relation to each other.
Many features have their origins in the development practice at Elektrobit and thus address specific needs of programmers, integrators and system developers. For example, visualized data always remains interlinked in different ways – if the user sets a marker in a chart, for example, this marker is automatically adopted and displayed in all linked charts and tables as well.
As a development tool aimed primarily at the automobile industry, EB solys also supports the correlation of log data with geodata, enabling it for example to show system events in combination with a map display and, if required, recorded camera images.
The screenshot below shows an example where the path of a calculated route from a navigation system has been reconstructed from monitored IPC messages.
EB solys can be customized and extended at various points. The runtime data capturing can be enlarged by additional target agent plugins. Importers can be implemented for any kind of logs, which are not created originally by the target agent. You can hook in specific decoders, that transforms arbitrary non-primitive binary data into structured readable text. And finally you can use the built-in script engine to add new functionality by accessing the runtime data and UI resources. A rich API, which is based on top of the programming language Xtend, enables users to extend the basic feature set of EB solys through expressive scripts. The IDE within EB solys comprises an editor for developing Xtend scripts. It is possible to instantly compile in the background and execute through annotations. This allows for very short turnaround times when integrating new functions.
Following code snippet shows how you can use the script API to access the collected runtime data and how the scripting capabilities are interlocked with the UI resources.
The code explained:
As mentioned in the beginning EB solys is also shipped with built-in support for Franca, which means that you are able to track back a runtime message (e.g. an IPC call) to its origin Franca method.
Some really helpful features can be derived from that functionality, such as the possibility to generate sequence diagrams from IPC traces (see screenshot above) or checking if a Franca contract is violated or not. Latter use cases will be described in detail in our upcoming and final post of this blog series. Stay tuned.
In case you are curious and want to try EB solys in the meantime you can download a free version. After applying for a license key you can test the full featured version for one month. If you are interested in the target agent development you can visit our Github repository.