Distributed Program Testing with Reproducible Simulation Time

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing methods for testing data processing distributed to multiple programs lack a reproducible global simulation time frame, which is crucial for synchronizing asynchronous program execution and ensuring reliable error detection.

Innovation Solution

Implementing an event simulator and replay unit to generate and manage test events that synchronize the execution and data communication of multiple programs within a shared, reproducible global time frame, using start-test, ending-test, output-data-visibility, and input-data-visibility events.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If Software-in-the-Loop testing is used for testing distributed data processing, then flexibility and cost-effectiveness are improved, but simulation time reproducibility deteriorates

Engineering Contradiction:
Improvetesting flexibilityVSAvoidsimulation time reproducibility
Core Design Contradiction:
Adaptability or versatilityVSLoss of time

Solution Approach 1:

The patent applies preliminary action by pre-defining a global simulation time frame and generating test events with specific timestamps before execution. The event simulator creates a structured sequence of test events that dictate when each program should start, end, or exchange data, ensuring that the simulation follows a reproducible timeline regardless of actual execution variations.

Inventive Principle:
Principle #10Preliminary action

Solution Approach 2:

The patent introduces an event simulator as an intermediary component that mediates between the test scenario definition and the actual program execution. This intermediary generates and manages test events, controlling the timing and synchronization of distributed programs, thereby decoupling the logical simulation time from actual execution time and enabling reproducible results.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Device complexity

If asynchronous program execution is used for distributed data processing, then program independence and modularity are improved, but synchronization and error detection capability deteriorate

Engineering Contradiction:
Improveprogram structure simplicityVSAvoiderror detection capability
Core Design Contradiction:
Device complexityVSReliability

Solution Approach 1:

The patent implements feedback mechanisms through the replay unit, which records actual execution results and compares them against expected outcomes defined in the test scenario. The system provides feedback by identifying deviations between simulated and actual behavior, enabling error detection in asynchronous executions while maintaining program independence.

Inventive Principle:
Principle #23Feedback

Solution Approach 2:

The patent replaces traditional mechanical synchronization methods with an event-driven computational approach. Instead of using locks, semaphores, or other synchronization primitives that would complicate the asynchronous program structure, the system uses an event simulator to coordinate program execution through timestamped events, maintaining simplicity while enabling synchronization.

Inventive Principle:
Principle #28Mechanics substitution (Replace mechanical system)

Data Source

PatentUS12373331B2Method for testing a data processing distributed to multiple programs
Publication Date: 2025.07.29 ROBERT BOSCH GMBH
  • US12373331B2 patent drawing
  • US12373331B2 patent drawing
  • US12373331B2 patent drawing

AI summary

A method for testing a data processing distributed to multiple programs. The method includes executing an event simulator which, according to a predefined test scenario for testing multiple programs, generates test events for each program, and a replay unit, which is connected to the event simulator, and for each program starts a data processing by the program during a start-test event for the program, receives output data generated by the program and forwards them to one or to multiple of the other programs during an output-data-visibility event, and ends the data processing by the program during an ending-test event for the program.