Computer-implemented method for configuring a simulation

Abstract

The invention relates to a computer-implemented method for configuring a simulation which comprises components (2a, 2b) which use a common memory (13), wherein the common memory (13) has a memory interface having a plurality of interface elements (4a-4e) which each provide access to a memory address via a symbolic path, and the components (2a, 2b) each have an individual component interface (5a, 5b) such that the components (2a, 2b) can, via their individual component interfaces (5a, 5b) connected to the memory interface, access memory addresses of the memory (13) which are accessible via an associated interface element (4a-4e) of the memory interface, comprising the following method steps: capturing individual component interface descriptions (6a, 6b), which each describe an individual component interface (5a, 5b) and each describe only the interface elements (4a-4e) of the memory interface which are relevant to the particular individual component interface (5a, 5b) by specifying via which symbolic path the particular individual component interface (5a, 5b) expects to access the memory (13) via a specific interface element (4a-4e) of the memory interface; combining the individual component interface descriptions (6a, 6b) to form an overall interface description (3); and, using the overall interface description (3), carrying out a consistency check as to whether all interface elements (4a-4e) of the memory interface which are described in said overall interface description are described such that said interface elements provide an access connection to the common memory (13) via exactly one symbolic path each. Robust and efficient modeling of data flows is thus made possible.

Description

[0001] Computer-implemented method for configuring a simulation

[0002] The invention relates to a computer-implemented method for configuring a simulation comprising components using a common memory, wherein the common memory has a memory interface with a plurality of interface elements, each providing access to a memory address via a symbolic path, and the components each have an individual component interface, so that the components can access such memory addresses of the memory via their individual component interfaces connected to the memory interface, which are accessible via a respective interface element of the memory interface.

[0003] Data port blocks are known from the prior art, allowing the formulation of data interfaces. These data interfaces can be used to implement communication with an I / O function or another model. The ports of the remote device (e.g., the I / O function) are mapped to the ports of the data port blocks, i.e., connected via a symbolic link. Changes to such a data interface generally require adjustments on both sides and to the symbolic connection.

[0004] Furthermore, data stores are known within the framework of a data storage concept. These offer the possibility of specifying linear or structured memory that is available in the model for random access (read and write). While exchanging data between multiple models is not usually directly supported, it is also modelable. However, this requires code generation for the model and additional constraints imposed by the simulation tool that integrates the models into the simulation application. These constraints include, among other things, that these models reside in the same memory area. If this data store approach is considered a common data interface, it is required that this entire data structure is always identical across all components of the simulation.Especially when communication occurs between models or between models and external components, the user must ensure that the data store data structure is identical across all communication partners. Changes to the data interface, in particular, pose a risk of inconsistencies. These inconsistencies typically lead to runtime errors in the resulting simulation application (e.g., incorrect signal connections or memory access errors).

[0005] When two models are combined in a simulation application, data store A, for example, defines a data interface. A data flow occurs from a data store write block to a data store read block because both blocks access the same field in the same memory A. If the definition of "A" changes in one of the models, for example, by adding another field or changing the data type of the fields, the interface becomes inconsistent and incompatible. The user must then update all involved models to ensure that they all work from the same definition.

[0006] This results in a significant effort required for interface changes. Both data port blocks and the data storage concept typically necessitate adjustments in all involved models. This increases the workload for developers and carries the risk of inconsistencies, especially in larger projects with many modules. In particular, the data storage concept usually lacks integrated mechanisms for verifying the consistency of data structures between models. This can lead to inconsistencies going unnoticed and only causing errors at runtime. The need for manual adjustments when data interfaces are changed further increases the risk of errors. A missing field or an incorrect data type can have serious consequences for the functionality of the entire simulation application.

[0007] Based on this, the object of the invention is to enable robust and efficient modeling of data flows. This object is achieved by the subject matter of claim 1. Preferred embodiments are found in the dependent claims.

[0008] According to the invention, a computer-implemented method for configuring a simulation is provided, which includes components using a common memory, wherein the common memory has a memory interface with a plurality of interface elements, each of which provides access to a memory address via a symbolic path, and the components each have an individual component interface, so that the components can access such memory addresses of the memory via their individual component interfaces connected to the memory interface, which are accessible via a respective interface element of the memory interface, with the following method steps:

[0009] Capturing individual component interface descriptions, each describing an individual component interface and only describing the interface elements of the memory interface relevant to that individual component interface, by specifying the symbolic path through which the individual component interface expects a specific interface element of the memory interface to access the memory.

[0010] Merging the individual component interface descriptions into a single overall interface description and

[0011] Perform a consistency check using the overall interface description to verify that all interface elements of the memory interface described therein are described in such a way that access to the common memory is associated with exactly one symbolic path each.

[0012] The invention thus provides a consistency check, which consists of testing whether the various individual component interfaces are consistent with each other in that they expect access via the same symbolic path for each individual interface element of the memory interface they use. The present invention therefore offers a way to configure simulations with shared memory by enabling an efficient method of defining and using memory interfaces between multiple components. Compared to existing approaches, it offers several advantages, particularly with regard to the flexibility of interface definition, automatic consistency checking, and improved modularity of simulation applications.

[0013] One aspect of the invention is the ability for each component to define its own interface independently, without requiring complete knowledge of the entire memory interface. While in conventional systems all participating components must access a centrally defined interface, the invention allows for decentralized and individual descriptions. Each component specifies only the parts of the memory interface relevant to it and indicates the symbolic path for access. This simplifies development, as changes to one component do not necessarily require extensive modifications to other components. Only when the individual interface descriptions are combined does a complete interface description emerge, which can then be automatically verified.

[0014] A further advantage of the invention lies in the automatic consistency check. Conventional systems for modeling data flows in simulation applications require manual synchronization of interface descriptions. This often leads to inconsistencies that are only discovered at runtime, resulting in errors that are difficult to identify. In contrast, the approach presented here ensures that the consistency of the overall interface description is checked before the simulation. By comparing all symbolic paths, it is ensured that each component accesses a uniform and error-free interface. This largely avoids runtime errors resulting from inconsistent interfaces.

[0015] Another advantage of the invention lies in the improved modularity and maintainability of simulation applications. Conventional solutions require a comprehensive adjustment of all involved models whenever an interface is changed, which complicates further development and is associated with considerable effort. In contrast, the method presented here enables incremental development, in which new components can be easily added without having to manually revise existing interfaces. This reduces maintenance effort and allows for simpler development of simulation models.

[0016] The invention also supports the modeling and use of deeply nested data structures. While existing methods require that all participating models use exactly the same data structure, the solution described here allows for more flexible handling. Components can refer only to the parts of the structure relevant to them, without having to encompass the entire structure in their interface description. This simplifies changes to the data structure and prevents an adjustment in one place from unintentionally requiring changes in numerous other components.

[0017] In addition to internal flexibility within a simulation environment, the invention also supports the seamless integration of external components. In many conventional systems, interfaces are limited to a specific modeling environment, meaning that external functions, such as I / O processes, can only be integrated through additional integration steps. The solution presented here defines the interfaces independently of the simulation environment, enabling the easy integration of external systems. This results in greater interoperability, which is particularly advantageous in networked simulation scenarios.

[0018] According to one embodiment of the invention, the individual component interfaces are described outside the device that provides the shared memory. This means that each component defines its interface independently of the central memory management, without being directly involved in the implementation of the memory structure. This architecture offers several advantages. First, it increases the modularity of the simulation environment, since each component can autonomously define its interface without relying on a central instance. This simplifies the development of new components and enables the parallel development of multiple modules without requiring complete knowledge of the overall structure. Another advantage of this embodiment is the flexibility in defining the memory interfaces.Because the interfaces are described outside of memory management, different components can use different parts of the interface or define their own requirements without necessarily leading to conflicts. This reduces the coordination effort between developers and facilitates the extension of existing interfaces, as new components can add their interface descriptions independently.

[0019] Furthermore, this architecture enables effective consistency checks and improved maintainability. Since the individual interfaces are defined separately from the central memory management, they can be independently checked and validated before being integrated into the overall system. This not only simplifies error analysis but also ensures greater simulation robustness, as incompatibilities can be detected and corrected early on. Finally, this solution improves interoperability between different systems and simulation environments. Because the interfaces are defined independently of the memory, they can be flexibly adapted to different requirements without requiring fundamental changes to the shared memory itself. This facilitates the integration of external components and enables consistent simulations across different platforms.

[0020] According to one embodiment of the invention, the consistency check verifies whether different component interface descriptions expect matching data types and / or dimensions at the same interface element. This ensures that all involved components access a consistent data structure and prevents potential errors that could arise from inconsistent type definitions. An advantage of this function lies in the automatic avoidance of runtime errors that could be caused by faulty or inconsistent interface definitions. In conventional systems, for example, one component might expect a variable as an integer, while another component interprets it as a floating-point number. Such inconsistencies can lead to serious computational errors or even a simulation crash.The planned consistency check will identify and resolve such conflicts in advance.

[0021] Furthermore, this check increases the reliability and maintainability of the simulation application. Developers no longer need to manually ensure that all components use the correct data types and dimensions, as the consistency check handles this automatically. This facilitates collaboration in large development projects where multiple teams work independently on different modules. Another advantage is the flexibility in extending interfaces. Because the consistency check ensures that new components are compatible with existing ones, developers can easily add new modules without worrying about hidden type or dimension conflicts. This reduces development effort and enables faster integration of new features into existing simulation environments.

[0022] According to one embodiment of the invention, modification of a symbolic path, via which access to the shared memory is provided through an interface element, is permitted, provided that the respective interface element is not included in at least one component interface description. This offers advantages in terms of interface design flexibility, the adaptability of simulation models, and the long-term maintainability of the simulation environment. One advantage of this feature is the dynamic adaptation of symbolic paths without affecting existing components. In conventional systems, symbolic paths are sometimes statically defined, so any change can potentially lead to conflicts or incompatibilities with existing models.The present invention enables the targeted adaptation of symbolic paths, provided these are not referenced in an existing component interface description. This allows for continuous adaptation of the memory interface to new requirements without unintentionally disrupting functioning components.

[0023] Furthermore, this solution improves the maintainability and scalability of simulation models. Since changes are only made where no existing components are affected, developers can extend or restructure interfaces without having to make extensive modifications to existing models. This reduces development effort and facilitates the iterative evolution of the simulation environment. Another advantage is the avoidance of unnecessary dependencies between components. In traditional solutions, a previous naming or structuring of interface elements can have long-term effects on all components that use these interfaces. The present invention ensures that changes to symbolic paths are only subject to restrictions if they actually affect an existing interface description.This provides greater flexibility in the storage structure and enables more efficient management of the simulation data.

[0024] According to one embodiment of the invention, the consistency check is performed automatically, generating an error message and / or automatically correcting any detected inconsistencies. This automation offers advantages in terms of error prevention, modeling efficiency, and the overall reliability of the simulation application. One benefit of this feature is the early detection of inconsistencies before they lead to runtime errors. In conventional systems, developers often have to manually check whether all components are operating consistently with the memory interface. Errors are frequently detected late in the development phase or even during the simulation itself, resulting in time-consuming debugging. The automatic consistency check ensures that inconsistencies are detected immediately, allowing for early intervention.

[0025] Another advantage lies in the reduction of manual adjustments. Since consistency checking is automated, developers no longer need to manually verify the correctness of every interface description. This saves valuable time and reduces the risk of human error. The automatic generation of error messages ensures that inconsistencies can be specifically identified and resolved, while potential automatic correction allows certain inconsistencies to be adjusted directly without developer intervention. Furthermore, this implementation increases the reliability and stability of the simulation application. Automatic consistency checking ensures that all involved components operate with a uniform and error-free interface. This reduces the risk of unexpected runtime problems that could be caused by inconsistent interfaces or incorrect memory address assignments.

[0026] According to one embodiment of the invention, each symbolic path is assigned a memory address in the shared memory. In other words, each symbolic path is only resolved to a specific memory address at the end, when the entire memory interface is assembled. This makes it possible to generate and compile code for a component without knowing the respective memory addresses beforehand. As a result, memory addressing remains flexible and dynamic until the final configuration step. This offers advantages in terms of modularity, development efficiency, and component reusability. A key advantage of this approach is the decoupling of component development from memory management. In many conventional systems, memory addresses must be defined in advance before code for a component can be generated and compiled.This often means that changes to the memory structure require re-adapting and recompiling all involved components. However, the method described here allows code for a component to be written and compiled before the final memory addressing is determined. This enables the parallel development of different simulation modules, as they can be built independently and integrated into the overall system later. Another advantage is the increased flexibility in memory address allocation. Since the final memory address assignment only occurs when the entire memory interface is assembled, these addresses can be dynamically adjusted to the current situation. This is particularly beneficial for large and complex simulations, as memory requirements frequently change during development.Late address resolution ensures efficient memory management without the need to assign fixed addresses early on that might not be optimally utilized later. This approach also increases the reusability and portability of components. Because a component's code can be generated independently of fixed memory addressing, the same component can be easily deployed in different simulation scenarios or on different platforms. This reduces the effort required for modifications and allows for more flexible use of already developed modules.

[0027] According to one embodiment of the invention, the simulation is either a HIL simulation or a SIL simulation. HIL (hardware-in-the-loop) and SIL (software-in-the-loop) simulations are two essential methods for validating and developing embedded systems, particularly in the automotive, aerospace, and automation industries. Both approaches allow control software to be tested in a simulated environment, but with different focuses.

[0028] In hardware-in-the-loop (HIL) simulation, a real electronic control unit (ECU) is integrated into a simulation environment, allowing it to be tested under realistic conditions. The physical environment with which the ECU would normally interact is replicated by a simulation that provides sensor and actuator signals in real time. This allows the ECU to operate as if it were actually integrated into the real system. This enables early hardware validation, even before the actual physical system is fully developed. HIL simulation offers several advantages: It allows ECUs to be tested under realistic conditions, errors to be identified early, and control algorithms to be optimized. Furthermore, expensive or hazardous test scenarios can be performed in a safe and controlled environment without the need for physical prototypes.

[0029] In contrast, SIL simulation tests the control software in a fully simulated environment without using a real control unit. Instead, the software runs in a simulation model that replicates the hardware environment. This allows the software to be developed, tested, and optimized independently of the actual hardware. SIL simulation offers several advantages: It enables early software validation, automated testing, and continuous integration into the development process. Furthermore, software changes can be implemented quickly and flexibly because no physical hardware is required.

[0030] The invention described here can be helpful in both HIL and SIL simulations, as it enables efficient and consistent modeling of data flows between simulation components. Particularly in HIL simulations, an accurate mapping of the interfaces is essential to ensure error-free communication between real ECUs and simulated environments. Through automatic consistency checking and flexible interface definition, the invention contributes to optimizing development processes and preventing errors early on, thereby significantly improving both the reliability and efficiency of simulations.

[0031] Furthermore, according to one embodiment of the invention, the simulation comprises at least one internal component of a simulation tool used for the simulation, and this internal component has an interface description that is taken into account alongside the individual component interface descriptions when merging to form the overall interface description. In this case, the overall interface description is therefore based not only on the component interface descriptions but also on the interface description of this internal component. The invention is explained in more detail below with reference to the drawings and a preferred embodiment.

[0032] The drawings show

[0033] Fig. 1 shows a flowchart for a method according to an embodiment of the invention and

[0034] Fig. 2 schematically shows the components of a simulation for which the method according to the embodiment of the invention is used.

[0035] Fig. 1 shows a flowchart for a method for configuring a simulation which, as shown in Fig. 2, comprises components 2a, 2b utilizing a shared memory 13. The shared memory 13 has a memory interface with a plurality of interface elements 4a-4e, each providing access to a memory address via a symbolic path. Each of the components 2a, 2b has an individual component interface 5a, 5b, through which it is connected to the memory interface and can thus access the corresponding memory addresses. The simulation can be either a HIL simulation or a SIL simulation. Furthermore, an internal component 10 of the simulation tool 8 is shown, which has an interface description 11 and is connected to the shared memory 13 via an internal component interface 1.

[0036] The process begins in step S1 with the recording of individual component interface descriptions 6a, 6b, each comprising only the interface elements 4a-4e of the memory interface relevant to the respective individual component interface 5a, 5b. This is done by specifying the symbolic path via which the respective component 2a, 2b expects access to a specific interface element 4a-4e of the memory interface. The individual component interfaces 5a, 5b are described independently of the simulation tool 8 on which the actual simulation application 9 runs and which provides the shared memory 13. This results in greater flexibility in the modeling and improved modularity of the simulation application, since each component 2a, 2b can define its interface description autonomously.

[0037] In the next step, S2, the individual component interface descriptions 6a and 6b, and the interface description 11 of the internal component 10, are merged into a single overall interface description 3. This has the advantage that different components 2a and 2b can define their interfaces independently of each other, without requiring complete knowledge of the entire memory interface. Only upon merging do they create a complete picture of all relevant interfaces, thus ensuring that all components 2a and 2b operate with a uniform and error-free interface.

[0038] After the merge, step S3 performs an automated consistency check of the overall interface description 3. This check verifies whether all interface elements 4a-4e of the storage interface are described in such a way that access to each is via exactly one symbolic path. Furthermore, it checks whether different component interface descriptions 6a and 6b expect matching data types and dimensions at the same interface element 4a-4e. This check ensures that no inconsistencies or type conflicts arise between the involved components 2a and 2b. Because the consistency check is automated, potential errors are detected early, before they can lead to runtime problems. If an inconsistency is detected, an error message is generated, and an automatic correction can also be performed.This significantly reduces the manual effort for developers and minimizes the risk of human error.

[0039] Another function of the procedure in step S4 is to allow the modification of a symbolic path through which access to the shared memory 13 is provided via an interface element 4a-4e. However, this is only possible if the respective interface element 4a-4e is not included in at least one component interface description 6a, 6b. This keeps the system flexible and allows for the gradual adaptation of the memory interface to new requirements without affecting existing, functioning components 2a, 2b. At the same time, unnecessary dependencies between components 2a, 2b are avoided, since changes are only made where no existing interface is affected.

[0040] In the final step S5, each symbolic path is assigned a specific memory address in shared memory 13. This assignment only occurs at the end of the configuration process, once the overall interface description 3 has been defined. This ensures that memory addressing remains flexible and dynamic until the final step. This has the advantage that code for a component 2a or 2b can be generated and compiled without needing to know the final memory addresses. In conventional systems, memory addresses often have to be specified in advance, which leads to a re-adjustment and recompilation of all affected components if changes are made. Alternatively, it is possible to use model port blocks. However, this requires copying the memory at runtime, which increases runtime and requires additional memory.The late address resolution allows the development of different simulation modules to be carried out independently of each other, which facilitates the parallelization of development and increases the reusability of components 2a, 2b.

[0041] Overall, the method offers a robust and efficient way to configure simulations with shared memory. 13 The decentralized definition of individual component interfaces 5a, 5b ensures greater flexibility and modularity, while automated consistency checking identifies and corrects potential errors early on. The ability to dynamically adjust symbolic paths reduces unnecessary dependencies and facilitates the maintenance and further development of the simulation environment in the simulation application 9 within the simulation tool 8. Finally, the late allocation of memory addresses enables efficient memory management and increases the reusability of software modules in different simulation scenarios. This helps to reduce development effort, minimize the potential for errors, and increase the efficiency of the entire simulation application 9.

[0042] Component interfaces of the internal component a, 2b Components of the simulation

[0043] Overall interface description

[0044] a - 4e Interface elements

[0045] a, 5b Component interfaces

[0046] a, 6b Component interface descriptions Simulation tool

[0047] Simulation application

[0048] 0 internal component of the simulation tool

[0049] 1. Interface description of the internal component 3. Shared memory with memory interface

Claims

Patent claims 1. A computer-implemented method for configuring a simulation comprising components (2a, 2b) utilizing a common memory (13), wherein the common memory (13) has a memory interface with a plurality of interface elements (4a - 4e), each providing access to a memory address via a symbolic path, and the components (2a, 2b) each have an individual component interface (5a, 5b) such that the components (2a, 2b) can access, via their individual component interfaces (5a, 5b) connected to the memory interface, such memory addresses of the memory (13) that are accessible via a respective interface element (4a - 4e) of the memory interface, comprising the following method steps: Capturing individual component interface descriptions (6a, 6b) that each describe an individual component interface (5a, 5b) and describe only the interface elements (4a - 4e) of the memory interface relevant to the respective individual component interface (5a, 5b) by specifying the symbolic path by which the respective individual component interface (5a, 5b) expects access to the memory (13) via a specific interface element (4a - 4e) of the memory interface. Combining the individual component interface descriptions (6a, 6b) into an overall interface description (3) and Performing a consistency check using the overall interface description (3) to verify that all interface elements (4a - 4e) of the memory interface described therein are described in such a way that access to the common memory (13) is associated with them via exactly one symbolic path each.

2. A computer-implemented method according to claim 1, wherein the individual component interfaces (5a, 5b) are described outside the device (8) that provides the common memory (13).

3. A computer-implemented method according to any of the preceding claims, wherein, as part of the consistency check, it is verified whether different component interface descriptions (6a, 6b) expect matching data types and / or dimensions at the same interface element (4a - 4e).

4. Computer-implemented method according to one of the preceding claims, wherein the modification of a symbolic path via which access to the common memory (13) is provided via an interface element (4a - 4e) is permitted, provided that the respective interface element (4a - 4e) is not included in at least one component interface description (6a, 6b).

5. Computer-implemented method according to one of the preceding claims, wherein the consistency check is performed automatically and an error message is generated and / or an automatic correction is performed in the event of an inconsistency being detected.

6. Computer-implemented method according to one of the preceding claims, wherein each symbolic path is assigned a memory address in the common memory (13).

7. Computer-implemented method according to any of the preceding claims, wherein the simulation is a HIL simulation or a SIL simulation.

8. Computer-implemented method according to one of the preceding claims, wherein the simulation comprises at least one internal component (10) of a simulation tool (8) used for the simulation and this internal component (10) has an interface description (11) which is taken into account when merging to form the overall interface description (3) alongside the individual component interface descriptions (6a, 6b).

Images