emmtrix
Dependency
Analyzer (eDA)
The Tool to Analyze the Data Dependencies of Your Application
emmtrix Dependency Analyzer (eDA) assists you with the safety analysis of your applications: Results from a data dependency analysis of the source code can be used to:
- Verify freedom from interference
- Propagate different safety levels of variables
- Detect mixed-criticality dependencies (variables with different safety levels)
- Verify event chains between input and output signals of the system
A further use case is the optimization of your testing strategies by identifying which subsystems are affected by a change in the source code and, more importantly, which subsystems are not and therefore do not have to be tested again. The tool can easily be integrated into CI flows offering automation, versioning and logging.
See our tool in action. Contact us to request a demo or to set up a chat or meeting.
Dependency Analysis of AUTOSAR Software Components
Together with customers from automotive, we have implemented support for a use case so that our emmtrix Dependency Analyzer (eDA) can be used to extract and visualize the internal data dependencies between AUTOSAR R-Ports and P-Ports of software components (SWCs) by analyzing their internal behavior.
A typical development flow in automotive is the usage of AUTOSAR to specify different software components and runnable entities. Simulink and Stateflow are used to implement the actual functionality and TargetLink is then used to generate the C code for the target platform. All data exchange in the application is typically modelled using AUTOSAR Runnables while the source code of the runtime environment is generated at the end when all components are integrated.
Figure 1: Typical AUTOSAR Workflow with Integrated eDA
eDA can be used to automatically analyze the generated C code regarding its data dependencies. The AUTOSAR model is used as basis to generate analyzable code and the results of the source code analysis are mapped back to the data prototypes, variables and SWC ports as defined in the AUTOSAR model. This approach allows the verification that in the generated C code, all data dependencies are according to the model and no undesired connections exist between input and output ports of the model.
Results can be exported in exchange formats like XML or JSON or visualized like in the image / in interactive graphical representations below.
Figure 2: Internal Data Dependencies of a Runnable
Figure 3 shows the visualization of dependencies across multiple subsystems.
Figure 3: Signal-Tracing across Subsystems
Use Cases
Enhancing Emissions Compliance
In response to the 2015 emissions scandal, global regulatory bodies have significantly strengthened the requirements for vehicle emissions compliance and the integrity of On-Board Diagnostics (OBD) systems. Key authorities such as the Environmental Protection Agency (EPA) in the United States, the California Air Resources Board (CARB), and equivalent bodies in the European Union, under frameworks like the Euro Norms, are at the forefront of enforcing these enhanced regulations. Automobile manufacturers are now mandated to rigorously demonstrate that their vehicles, particularly the OBD software, are devoid of any manipulations and adhere to the prevailing emissions standards. This rigorous demonstration includes the submission of comprehensive documentation detailing the operation of their OBD systems. Such documentation must encompass thorough descriptions of the algorithms deployed for monitoring emissions, ensuring transparency and accountability. This step is crucial in rebuilding trust in automotive compliance and ensuring that vehicles on the road minimise emissions, aligning with initiatives like the Emission Neutral Default Action (ENDA) to mitigate any adverse environmental impacts.
The issue: Auto manufacturers face the challenge of ensuring their OBD software is fully compliant with stringent emission regulations. This entails not only adhering to legal requirements but also maintaining transparency and traceability in how the software manages and influences emissions. With regulatory scrutiny intensifying, manufacturers need a reliable method to analyze and document the behavior of their OBD systems under various conditions.
The solution: emmtrix Dependency Analyzer offers a groundbreaking solution for auto manufacturers seeking to navigate the complexities of emissions compliance. This static code analysis tool delves into the source code of OBD software, mapping out how specific input variables affect emission outputs. By identifying the intricate relationships between different components and variables, emmtrix Dependency Analyzer provides an unparalleled level of insight into the software’s operational logic.
Freedom from Interference Analysis
In the development of safety-critical automotive software, ensuring the integrity and reliability of systems across varying levels of safety requirements is paramount. The emmtrix Dependency Analyzer offers a sophisticated solution to address the challenges associated with ensuring “Freedom from Interference” between components operating at different Automotive Safety Integrity Levels (ASILs). This use case outlines how the emmtrix Dependency Analyzer can be applied to identify and manage potential interference risks, thereby supporting compliance with ISO 26262 standards.
The issue: In modern automotive systems, software components with different safety requirements often share resources, such as CPUs, memory, or I/O systems. This shared environment raises the risk that lower-criticality components might interfere with the functioning of higher-criticality components, potentially leading to safety hazards. Ensuring freedom from interference is a regulatory requirement and critical for achieving functional safety certification under ISO 26262. However, manually identifying potential interference paths and ensuring isolation between components of different ASIL levels is both time-consuming and prone to human error.
The solution: emmtrix Dependency Analyzer automates the process of identifying and analyzing dependencies between software variables across different ASIL levels. By performing a comprehensive static code analysis, the tool maps out how each variable influences others, creating a detailed dependency graph that highlights potential interference risks between components of varying criticality.
Event Chain Analysis
In today’s complex software environments, understanding the dependencies and interactions between different parts of a system is critical. The emmtrix Dependency Analyzer is designed to address this challenge by providing deep insights into how variables within individual runnables influence each other across time. This use case explores the application of the emmtrix Dependency Analyzer for conducting an Event Chain Analysis, a method crucial for identifying and managing risks in software development projects.
The issue: In large-scale software projects, especially those involving real-time systems, it’s common to encounter issues related to timing, sequencing, and dependencies between tasks. Developers and project managers often struggle to trace how changes in one part of the system can affect others, potentially leading to unforeseen delays, bugs, or system failures. Without a detailed understanding of these dependencies, mitigating risks and ensuring system reliability becomes a shot in the dark.
The solution: emmtrix Dependency Analyzer offers a powerful solution by enabling users to perform a detailed analysis of dependencies within their software. By focusing on individual runnables, the tool can identify how changes in input variables affect output variables, including the detection of delay elements that indicate when a variable change will impact the system in the next time step. This capability is invaluable for constructing an accurate Event Chain Analysis, which is essential for risk identification and management.
Features
- Analysis takes all possible paths of the control flow graph into consideration to ignore dependencies that can never occur
- Data and control dependencies between variables are calculated
- All calls to sub-functions are taken into account
- Supports analysis of programs consisting of multiple compilation unit (source files)
- Supports analysis of delayed dependencies where values are stored in a variable and only fed to the output when the function is called again
Technical Details
Support
For more information on emmtrix Dependency Analyzer or to request a demo, a chat or a meeting use our contact form or get directly in touch. We’re looking forward to hearing from you.
Rainer Heim