Debugging Distributed Real-Time Software via Time-Controlled Segmentation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Debugging software components in distributed real-time systems is challenging due to the introduction of debugging aids altering the runtime behavior, which can cause errors and is difficult to trace back to specific programming errors without disrupting real-time operations.
Innovation Solution
An extended development system is created where computer nodes of the target hardware are connected to development systems via time-controlled distribution units, allowing simultaneous execution of software components on both systems with synchronized activation signals and intermediate results written to external memory for error analysis.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Difficulty of detecting and measuring
If debugging aids are introduced into a software component to enable error detection and intermediate result checking, then debugging capability is improved, but the runtime behavior of the software component is altered which can cause errors and disrupt real-time operations
Solution Approach 1:
The system is segmented into two separate execution environments: the target hardware running the real-time version and the development system running the extended simulation version. This segmentation allows debugging aids to be applied only to the simulation version without affecting the runtime behavior of the real-time version, thus resolving the contradiction between debugging capability and runtime reliability.
Solution Approach 2:
An extended simulation version of the software component is created as a copy on the development system. This copy includes debugging aids and can be executed independently to detect errors and check intermediate results. The original real-time version on target hardware remains unchanged, preserving its runtime behavior and reliability.
2Difficulty of detecting and measuring
If the software component is expanded with debugging aids to check intermediate results, then error detection capability is improved, but the processing time and real-time behavior of the software component deteriorates
Solution Approach 1:
The execution environment is segmented into target hardware for real-time operations and development system for debugging operations. The extended simulation version with debugging aids runs only on the development system, allowing comprehensive error detection without adding processing overhead to the time-critical real-time version on target hardware.
Solution Approach 2:
The software component is copied to create an extended simulation version that includes debugging aids. This copy performs additional error detection and intermediate result checking operations that would be too time-consuming for the real-time version, thus improving error detection capability without compromising real-time processing time constraints.
3Reliability
If debugging is performed on the target hardware to maintain real-time behavior, then real-time compliance is improved, but the ability to perform comprehensive error analysis and trace intermediate results deteriorates
Solution Approach 1:
The system separates real-time execution on target hardware from comprehensive debugging on the development system. The extended simulation version on the development system can perform detailed error analysis and trace intermediate results without the time constraints of real-time operations, while the target hardware maintains strict real-time compliance.
Solution Approach 2:
A simulation version of the software component is created on the development system that includes enhanced debugging capabilities. This copy can output intermediate results and perform comprehensive error analysis that would be impractical on target hardware, while the original real-time version maintains its time-critical performance and real-time compliance.
4Measurement precision
If the development system is extended to include target hardware nodes for simultaneous execution, then debugging accuracy under real-time conditions is improved, but the complexity of the development system increases
Solution Approach 1:
The development system is merged with the target hardware through time-controlled distribution units that connect both systems. This merging enables simultaneous execution of the software component on both platforms with synchronized activation signals, allowing debugging under realistic time constraints while maintaining a unified development environment.
Solution Approach 2:
Time-controlled distribution units act as intermediaries between the development system and target hardware. These intermediaries coordinate message exchange and synchronization between the two systems, enabling simultaneous execution and accurate debugging while managing the complexity of the extended development system through standardized communication protocols.
Data Source
Figure 1~2
AI summary
The invention relates to a method for debugging software components of a distributed real-time software system, wherein the target hardware comprises computer nodes and the development system comprises one or more computers. According to the invention, an enhanced development system is formed, in which enhanced development system the computer nodes of the target hardware are connected to the computers of the development system via one or more time-controlled distributer units, wherein the enhanced development system has a sparse global time of known precision, wherein the computer nodes of the target hardware exchange messages with the computers of the development system via one or more distributer units, and wherein, in a frame, a software component on the target hardware and, temporally parallel thereto, a software component in the development system are supplied with the same input data and executed, wherein the activation signals are triggered at the start of the two executions of the software component in the same sparse tick of the global time, and wherein the software component executed in the development system is enhanced in such a way that, during its execution, selected intermediate results are written on an external data memory.