Computing platform for simulating industrial systems and method for managing simulations

Abstract

A computing platform for simulating an industrial system and a method for managing simulations is disclosed. The method includes generating at least one instance of a simulation model of the industrial system, the method being characterized by: generating the instance (342) using a contiguous memory allocator for a dynamic memory region (252) associated with a first processor (242) of heterogeneous processors (242, 262); enabling a second processor (262) to use the instance (342) in the dynamic memory region (252) based on a memory pointer associated with an address of a copy (362) of the instance; and simulating the industrial system executed by the second processor (262) by accessing the copy (362) of the instance.

Description

Technical Field

[0001] The present invention relates to simulating industrial systems. In particular, the present invention relates to simulating industrial systems using heterogeneous processors. Background Art

[0002] When simulating an industrial system, one or more types of processors can be used to execute a simulation program that simulates the state variables of the industrial system. For example, in the case of an autonomous vehicle, a simulation program can be used to simulate suitable materials for the autonomous vehicle body. The simulation program can use a class instance that is a library with properties for various material types. The class instance can be a central processing unit (CPU) and therefore cannot be executed on a graphics processing unit (GPU).

[0003] In another example, the industrial system is a turbine. A simulation program can be used to simulate nitrogen oxides (NO x ) emissions. C++ classes can be used to read NO emissions from turbines. x Sensor data files containing sensor measurements. Furthermore, C++ classes can be used to perform operations on sensor data based on the simulation program. Sensor data can be read using the CPU. Since the data size is unknown in advance, dynamic allocation can occur, and the sensor data can be read into a memory location accessible to the CPU (CPU memory). Operations can then be performed on the memory location using the simulation program's functions.

[0004] In the previous example, if the same code needs to be used on the GPU, then the class instance may need to be compiled for the GPU code. However, the instance that reads the data from the CPU may not be directly shared. In order to share the instance that reads the data, an explicit copy / reconstruction of the class instance may need to be performed. In addition, dynamically allocated memory may need to be copied to GPU memory.

[0005] Figure 1 Explicit management of CPU memory / first memory 110 and GPU memory / second memory 120 according to the prior art is shown. Class instance 112 is copied from CPU memory 110 to GPU memory 120 using operation "copy" 132. Based on copy operation 132, class instance 122 is stored in GPU memory 120. Class instance 112 may request multiple dynamic allocations, such as dynamic allocation 114 and dynamic allocation 116. Dynamic allocations may need to be explicitly copied / reconstructed in GPU memory 120. For example, dynamic allocation 114 is copied using copy operation 134. As a result, dynamic allocation 114 is stored in GPU memory as dynamic allocation 126. Furthermore, dynamic allocation 116 is copied using copy operation 136 and stored in GPU memory 120 as dynamic allocation 124.

[0006] As the number of dynamic allocations increases, existing techniques can become increasingly complex. If there are a large number of dynamic allocations, each one may need to be tracked and copied via explicit code. If this is GPU or CPU code, this can be extremely intrusive in the source code to keep track. Summary of the Invention

[0007] Therefore, there is a need for improved management of simulation programs that can use heterogeneous processors.An object of the present invention is to provide a system and method for managing simulations of industrial systems that use heterogeneous processors for simulation.

[0008] For example, the objectives of the present invention are achieved by a method for managing a simulation of an industrial system using heterogeneous processors. The method includes generating at least one instance of a simulation model of the industrial system. The method is characterized by generating the instance using a contiguous memory allocator for a dynamic memory region associated with a first processor of the heterogeneous processors; enabling a second processor to use the instance in the dynamic memory region based on a memory pointer associated with an address of a copy of the instance; and simulating the industrial system by the second processor accessing the copy of the instance.

[0009] In another example, a computing platform for simulating an industrial system to achieve this purpose is disclosed. The computing platform includes heterogeneous processors. The computing platform includes a first memory accessible by a first processor and a second memory allocated based on usage of the first memory on a second processor; and a memory allocation module configured to generate at least one memory pointer for at least one instance of a simulation model of the industrial system, wherein the instance is initialized by the first processor and wherein a copy of the instance is used by the second processor.

[0010] Yet another example includes a computer program product having machine-readable instructions stored therein that, when executed by a computing platform disclosed herein, causes the computing platform to perform the method steps disclosed herein.

[0011] The technical effect of the continuous memory allocator, the allocated dynamic memory area and the memory pointer is to reduce the work of explicitly sharing code between heterogeneous processors. Therefore, errors caused by explicit memory management can be avoided. The present invention proposes a technology for implicitly managing the memory used by at least one heterogeneous processor. Specifically, an implicit method for sharing an instance of a simulation model of an industrial system between heterogeneous processors is provided. Therefore, the present invention implements complex initialization of classes (for example, reading data from disk, processing data, etc.) while using heterogeneous processors. In addition, the present invention advantageously enables the same code to be maintained when developing hybrid simulation programs executed using heterogeneous processors. In addition, since the same simulation program is executed in different architectures, the present invention enables simulation models to be tested more easily and efficiently. Therefore, the present invention can reduce the development time of simulation models and the simulation of industrial systems.

[0012] Before describing the proposed practice in more detail, it should be understood that various definitions of certain words and phrases are provided in this patent document, and those skilled in the art will understand that these definitions apply in many, if not most, instances to prior and future uses of such defined words and phrases. While some terms may include a variety of embodiments, the appended claims may expressly limit these terms to specific embodiments. It should also be understood that features explained in the context of the proposed method may also be included in the proposed system by appropriately configuring and adapting the system, and vice versa.

[0013] As used herein, an "industrial system" may refer to a system / facility used for production or manufacturing, and may be semi-automated or fully automated. An industrial system may be part of an automation environment, such as an industrial automation environment, a power plant automation environment, an autonomous vehicle automation environment, a laboratory automation environment, or a building automation environment. Furthermore, according to the present invention, an automation environment may include a combination of one or more industrial automation environments, laboratory automation environments, and building automation environments.

[0014] Industrial systems can also refer to control devices, sensors, and actuators that include physical devices and digital models that can be used to configure and control physical devices. For example, computer numerical control (CNC) machines, automation systems in industrial production facilities, motors, generators, etc. Industrial systems can also refer to complex systems that use one or more control devices, actuators, and sensors that interact with each other. For the purposes of the present invention, an industrial system is any system whose operations and functions can be simulated using heterogeneous processors. Those skilled in the art will understand that industrial systems are not limited to any particular industry because simulation applications are widely used in industry.

[0015] As used herein, “sensor data” is data associated with the operation and operating conditions of an industrial system. Sensor data can be received from different sources (e.g., sensors, user devices, etc.). Sensors measure operating parameters associated with a system. For example, sensors can include thermal imaging devices, vibration sensors, current and voltage sensors, etc. The term “operating parameters” refers to one or more characteristics of a system. Therefore, sensor data is a measurement of an operating parameter associated with the operation of the system. For example, sensor data can include data points representing vibration, temperature, current, magnetic flux, speed, power associated with an industrial system (such as a motor or rotor in an industrial environment). A simulation model can use the sensor data to generate at least one instance of the simulation model.

[0016] As used herein, "heterogeneous processors" refers to more than one type of processor or core. With respect to heterogeneous processors, a computing platform with heterogeneous processors has specialized processing capabilities. In one embodiment, a computing platform may include heterogeneous processors such as a central processing unit (CPU) and a graphics processing unit (GPU). For example, the heterogeneous processors include at least a CPU and a GPU, where the first processor is a CPU and the second processor is a GPU, or vice versa.

[0017] Heterogeneous processors are often useful for simulating industrial environments, particularly in co-stimulation scenarios. In one embodiment, instances and libraries of simulation models for executing industrial models are available in a first memory associated with a first processor. When a second processor is used to co-simulate the simulation model, the present invention makes the instances available to the second processor. Thus, the present invention addresses the situation where simulation instances or objects are stored in different dynamic address spaces in the first memory and can be called by the second processor along with associated virtual functions / dynamic allocations.

[0018] In one embodiment, the industrial system is an autonomous vehicle, and the simulation model includes an environmental model of the environment surrounding the autonomous vehicle, a physics-based model, and a predictive model for the operating parameters of the autonomous vehicle. The simulation model for the autonomous vehicle advantageously provides initial virtual testing, which can protect the manufacturer of the autonomous vehicle from losses due to potential collisions and accidents on the road. The simulation model can be configured to run an instance of the environmental model so that the controller of the autonomous vehicle can react to various traffic situations simulated by the environmental model. In one example, the traffic scenarios can be stored as a library in a first memory associated with the first processor. When initialized, each traffic scenario can be configured to request dynamic allocation from the first memory. In addition, the second processor can be used to simulate output signals (such as speed reduction) of the controller of the autonomous vehicle based on the initialized traffic scenario. Therefore, the present invention enables the second processor to access the initialized traffic scenario based on a memory pointer associated with the address of the copy of the traffic scenario.

[0019] For example, the method may include generating multiple instances of a simulation model based on multiple configurations of an autonomous vehicle and multiple objects and object parameters in the vehicle environment. The multiple instances may be generated by a first simulation application. In addition, the multiple configurations and the multiple objects and object parameters may be software libraries read by the first simulation application. The method may also include dynamically allocating the multiple instances in a dynamic memory area and copying the dynamic memory area to a second memory accessed by a second simulation application. In addition, the method may include co-simulating the initialized instances by the second application and determining an optimal configuration for the autonomous vehicle based on the co-simulation. Therefore, the present invention advantageously enables efficient use of heterogeneous processors to simulate and configure autonomous vehicles.

[0020] Those skilled in the art will appreciate that the example of an autonomous vehicle is not limiting in nature. The technical effects of the present invention are achieved in any industrial system simulated using a simulation model executed on heterogeneous processors.

[0021] In another embodiment, the industrial system is a turbine in an industrial plant, and wherein the simulation model includes physics-based functions and predictive functions to simulate the operation of the turbine. The simulation model of the turbine is configured to simulate all aspects of the turbine, including a detailed structural model of the turbine blades that determines stresses and strains. For example, in the case of a wind turbine, the simulation model may include an aerodynamic model of the rotor that simulates the operation of the wind turbine under wind conditions. In this example, wind scenarios can be generated based on historical measurements of weather conditions or by applying predictive functions based on machine learning models to weather conditions. The first processor can be configured to generate wind scenarios and store them as a library in a first memory. The aerodynamic model can be executed by the second processor by accessing the wind scenarios in the first memory based on a memory pointer associated with the address of the copy of the wind scenario.

[0022] In one embodiment, a method may include generating a contiguous memory allocator to allocate a dynamic memory region within a first memory of a first processor, wherein a simulation model is stored in the dynamic memory region within the first memory. The contiguous memory allocator is configured to allocate the dynamic memory region by defining a site / region in the first memory where instances can be individually allocated. The dynamic memory region advantageously facilitates flexible allocation and deallocation of memory with low overhead.

[0023] The method may further include providing a dynamic allocation by a continuous memory allocator in response to a request from the instance, wherein the dynamic allocation is provided in a dynamic memory area, wherein each dynamic allocation is relatively referenced by a specific memory pointer instance, wherein the specific memory pointer instance is configured to determine its relative distance to the dynamic allocation, and wherein the memory pointer is generated using the specific memory pointer instance. Thus, the method ensures that further allocations associated with the simulation instance will be made within the dynamic memory area. Furthermore, subsequent dynamic allocations are easily mapped based on the relative distance to the specific memory pointer instance. The memory pointer uses the relative distance to reference the dynamic allocation, whereby the second processor can access the dynamic allocation. Thus, the simulation model of the industrial system can be initialized by the first processor using complex initialization without considering explicit memory management between the first processor and the second processor.

[0024] In one embodiment, the method may include allocating a second memory associated with the second processor to the size of the first memory based on the consumption of the first memory by the simulation model stored in the dynamic memory area. Sufficient memory is provided to the second memory to store the simulation model, the simulation instance, and the subsequent dynamic allocation. The method may also include copying the first memory to the second memory based on the allocation, wherein the specific memory pointer instance points to the dynamic allocation in the second memory, and the simulation model can be accessed by the second processor for execution. By copying the contents of the first memory to the second memory, the dynamic memory area with the dynamic allocation and the specific memory pointer instance are copied to the second memory. The copied specific memory pointer is configured to generate a memory pointer that is dynamically allocated based on a relative distance mapping.

[0025] The method may include initializing an instance on a first processor, wherein the instance is initialized to perform at least one function; and referencing the initialized instance by a second processor using a memory pointer and an instance copy. Therefore, the present invention proposes that when a class (i.e., a simulation model) is instantiated, a tri-state copy of the instance can be made using conventional memory copying. The instance copy can be used by the second processor using a memory pointer. In addition, the method may include allocating a dynamic memory area to a first simulation application executed by the first processor, wherein the first application generates the initialized instance; and accessing the initialized instance by copying the dynamic memory area to a second memory associated with a second simulation application executed by the second processor, wherein the initialized instance is used by the second application to simulate the industrial system.

[0026] Therefore, the method may further include simulating the industrial system by executing the simulation model copied to the second memory by the second processor. This method is particularly advantageous when developing hybrid solutions for CPUs and GPUs. Significant reductions in development time can be achieved by having fewer errors due to explicit memory management. In addition, by using different architectures, testing simulation models can be made easier, more efficient, and more accurate.

[0027] In one embodiment, a method may include mapping addresses in a dynamic memory region to a set of memory pointers, wherein the set of memory pointers includes a memory pointer pointing to an address of an instance in the dynamic memory region. The method may also include generating a specific memory pointer instance based on a relative distance between the address of the specific memory pointer instance and the address of the instance in the dynamic memory.

[0028] In one embodiment, a method may include allocating a dynamic memory region accessible by heterogeneous processors, defining a specific memory pointer for an instance of the dynamic memory region, identifying whether the instance is specific to one of a first processor and a second processor, and sharing the instance and the instance copies between the heterogeneous processors based on the identification, wherein the specific memory pointer is used to determine the address of the instance in the dynamic memory region. This method advantageously provides a way to identify which functions are dedicated to the CPU and / or GPU. BRIEF DESCRIPTION OF THE DRAWINGS

[0029] Hereinafter, the present invention will be described using the embodiments shown in the drawings.

[0030] Figure 1 Explicit management between heterogeneous processors according to the prior art is shown;

[0031] Figure 2 A block diagram of a computing platform for simulating an industrial system according to an embodiment of the present invention is shown;

[0032] Figure 3 A flowchart illustrating a method for managing simulation of an industrial system using heterogeneous processors according to an embodiment of the present invention; and

[0033] Figure 4 The method steps for managing simulation of an industrial system using heterogeneous processors according to an embodiment of the present invention are shown. DETAILED DESCRIPTION

[0034] Below, embodiments for implementing the present invention are described in detail. Various embodiments are described with reference to the accompanying drawings, wherein like reference numerals are used to represent like elements throughout. In the following description, for purposes of explanation, numerous specific details are set forth to provide a thorough understanding of one or more embodiments. Obviously, such embodiments can be practiced without these specific details.

[0035] Figure 2 A block diagram of a computing platform 200 for simulating one or more autonomous vehicles using heterogeneous processors 242 , 262 is shown in accordance with an embodiment of the present invention.

[0036] Computing platform 200 includes an environment module 210 configured to generate an environment model reflecting the environment surrounding the autonomous vehicle. The environment model is generated from sensor data 212 and 214. Sensor data 212 includes sensor values ​​indicating acceleration, deceleration, wheel slip angle, and vehicle roll of the autonomous vehicle. Furthermore, sensor data 214 includes lidar, camera, and radar sensor data. Simulation of the autonomous vehicle can be performed by reconstructing sensor data 212 and 214 to generate the environment model. Thus, the environment model serves as a digital representation of the autonomous vehicle and its associated environment.

[0037] Computing platform 200 also includes a scenario database 220. Autonomous vehicle simulations are performed for a plurality of scenarios illustrating one or more traffic conditions. For the autonomous vehicle controller, it may be necessary to recognize and react to many complex situations. The scenarios are stored in scenario database 220.

[0038] Computing platform 200 includes a simulation module 230 configured to generate a simulation model. The simulation model is a physics-based model of the autonomous vehicle and an environment model. The simulation model may include multiple behavioral instances of the autonomous vehicle. Simulation module 230 includes a generator 232 that generates simulation instances. Simulation instances are generated from the simulation model and can be executed by heterogeneous processors 242 and 262. Simulation instances can be generated as objects created from the simulation module. The simulation module acts as a class from which objects, i.e., simulation instances, are created.

[0039] The computing platform 200 includes a computing unit 240, which includes heterogeneous processors 242 and 262. Figure 2 , the heterogeneous processors are a CPU 242 and a GPU 262. The computing unit 240 further includes a first memory 250 associated with the CPU 242 and a second memory 270 associated with the GPU 262. The computing unit 240 further includes a display 280 configured to display graphical user interfaces (GUIs) 244 and 264. In one embodiment, the computing unit 240 may include a simulation module 230, a scene database 220, and an environment module 210.

[0040] CPU 242 and GPU 262 execute simulation applications 256 and 274 stored in memories 250 and 270, respectively, to simulate the behavior of the autonomous vehicle. The results of the simulation are displayed on display 280 via GUIs 244 and 264, respectively.

[0041] The first memory 250 includes a dynamic memory region 252 and a memory allocator module 254. In operation, the memory allocator module 254 is configured to generate a contiguous memory allocator that allocates the dynamic memory region 252. In addition, the memory allocator module 254 is configured to use a specific memory pointer instance to generate a memory pointer used by the GPU 262. The details of the operation are described in Figure 3 Available in.

[0042] The continuous memory allocator can be used to instantiate simulation instances. When instantiated, the simulation instances can generate a unique representation of the simulation model. In addition, dynamic allocations requested by the simulation instances are provided by the continuous memory allocator within the dynamic memory region. The second memory 270 includes a copy 272 of the dynamic memory region. The GPU 262 can access the instantiated simulation instances in the dynamic memory region 252 via the instance copy 272 stored in the dynamic memory region. The dynamic memory region 252 includes a specific memory pointer instance that references the instantiated instance based on the relative distance of the instantiated instance from itself. The operation of the computing unit 240 is Figure 3 Instructions.

[0043] Figure 3 A flowchart of a method for managing a simulation of an autonomous vehicle using heterogeneous processors 242 and 262 according to an embodiment of the present invention is shown. At step 302, computing unit 240 receives a description of a simulation model having function 1, function 2, and a specific pointer P. Function 1 and function 2 are based on simulation operations performed using simulation applications 256 and 274.

[0044] At step 304, the contiguous memory allocator allocates instance memory for the simulation instance of the simulation model. At step 306, a simulation instance 342 and a specific memory pointer instance 344 are created in the CPU memory 250 within the dynamic memory region 252. The simulation instance 342 includes the specific memory pointer instance 344.

[0045] At step 308, dynamic memory is allocated for the specific memory pointer instance 344. At step 310, the continuous memory allocator performs a dynamic allocation in response to the request of the simulation instance 342. Dynamic allocations 346 and 348 are provided in the dynamic memory area. As shown, dynamic allocation A 346 and dynamic allocation B 348 can be provided randomly, so in the prior art, referencing dynamic allocations 346 and 348 is challenging (e.g., Figure 1 Each dynamic allocation 346 and 348 is relatively referenced by a particular memory pointer instance 344 based on its relative distance 350 to the dynamic allocation 346 and 348.

[0046] At step 312, CPU memory 250 is copied to GPU memory 270. Consequently, instance copy 362 of simulation instance 342 and pointer copy 364 of specific memory pointer instance 344 are created in dynamic memory copy 272. Dynamic allocations 346 and 348 are also copied to dynamic allocations 366 and 368. Pointer copy 364 may be different from specific memory pointer instance 344. However, pointer copy 364 is configured to reference dynamic allocations 366 and 368 based on relative distance 350.

[0047] At step 314, the simulation model is compiled using GPU 262. Furthermore, at step 316, GPU 262 may use pointer copy 364 to access dynamic allocations 366 and 368. Pointer copy 364 is capable of locating dynamic allocations 366 and 368 based on relative distance 350. Thus, the present invention overcomes the challenges of explicitly managing memory between CPU 242 and GPU 262.

[0048] In one example, simulation application 256 may involve simulating materials used in an autonomous vehicle. Simulating materials enables the determination of the strength, stiffness, and crash response of the autonomous vehicle. For simulation, simulation application 256 may initialize material properties associated with a C++ library that can be read only by CPU 242. Exemplary material properties include wavelength, elasticity, flame retardancy, electrical conductivity, and thermal conductivity. Simulation application 274 may involve simulating damage and fatigue of the vehicle after an autonomous hatch. The material library initialized by simulation application 256 is accessed by application 274 based on the methods described above.

[0049] Those skilled in the art will appreciate that the example of an autonomous vehicle can be extended to any industrial system simulated using heterogeneous processors. Figure 4 Method steps of a method for managing simulation of an industrial system using heterogeneous processors according to an embodiment of the present invention are shown.

[0050] The method includes generating at least one instance of a simulation model of an industrial system. The simulation model is a physics-based model of the industrial system and a machine learning-based predictive model. The simulation model can simulate multiple behavioral instances of the industrial system based on the physics-based model and the predictive model. The simulation instance is generated from the simulation model and can be executed by heterogeneous processors, and is therefore also referred to as a hybrid simulation model. The simulation instance can be generated as an object created from a simulation module. The simulation module serves as a class from which objects, i.e., simulation instances, are created.

[0051] As used herein, a "physics-based model" may include system identification, relevant components associated with the industrial system, operating conditions associated with the industrial system, system parameters, and relationships between system parameters and predicted performance indicators. For example, a physics-based model includes a 1-dimensional (D) representation, a 3D representation, a process, and an instrumentation representation associated with the industrial system. A physics-based model may also include the dynamics of the industrial system, representations of mechanical functions with electronics and controls, materials, and manufacturing methods. Furthermore, a physics-based model may be simulated to predict the behavior of an industrial system.

[0052] As used herein, a "predictive model" includes a data-based model of an industrial system. For example, a predictive model is generated by analyzing at least one of sensor data, historical operational data, and synthetic data associated with the industrial system using one or more machine learning algorithms (such as pattern recognition algorithms). Machine learning algorithms can be used to analyze sensor data in real time. Furthermore, historical operational data refers to sensor data at a given moment in time. Furthermore, synthetic data includes data generated using statistical prediction algorithms based on sensor data or historical operational data.

[0053] At step 410, at least one simulation instance (hereinafter referred to as instance) is created for a dynamic memory region associated with a first processor in the heterogeneous processors using a contiguous memory allocator. For example, as shown in step 306, the contiguous memory allocator is generated by the first processor to allocate a dynamic memory region in a first memory associated with the first processor. Therefore, at step 420, the contiguous memory allocator is generated to allocate the dynamic memory region.

[0054] Instances created in the dynamic memory area can request dynamic allocation. Therefore, in step 430, dynamic allocation is provided within the dynamic memory area. Thus, memory is allocated to the instance for additional functionality that can be initialized when the instance is instantiated. Step 430 also includes relatively referencing the dynamic allocation via a specific memory pointer instance. The specific memory pointer instance is configured to determine its relative distance to the dynamic allocation. For example, as shown in step 310.

[0055] At step 440, the instance is enabled for use by a second processor in the heterogeneous processors based on a memory pointer associated with the address of the copy of the instance. The memory pointer uses a specific memory pointer instance to determine the address of the copy of the instance. In one embodiment, the instance is copied by allocating a second memory associated with the second processor to the size of the first memory based on the consumption of the first memory by the instance created in the dynamic memory area. Furthermore, the instance is copied based on the allocation, wherein the specific memory pointer points to the copy of the instance in the second memory, and thereby the instance is accessible to the second processor for execution. For example, as shown in steps 312 and 316.

[0056] At step 450, the second processor simulates the industrial system by accessing the instance in the dynamic memory area. For example, the second processor may compile a simulation model using the instance copy. In one embodiment, step 450 may include executing a simulation application on the second processor using the specific memory pointer instance to reference the instance copy.

[0057] The present invention can take the form of a computer program product comprising a program module accessible from a computer executable or computer program product / computer readable medium, which stores program code used by or in combination with one or more computers, processors, or instruction execution systems. For the purposes of this specification, a computer-usable or computer-readable medium can be any device capable of containing, storing, communicating, propagating, or transmitting a program used by or in combination with an instruction execution system, device, or equipment. The medium can be an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system (or device or equipment) or a propagation medium, or itself, because signal carriers are not included in the definition of physical computer readable media, which includes semiconductor or solid-state memory, magnetic tape, removable computer disk, random access memory (RAM), read-only memory (ROM), hard disk, and optical disk, such as compact disc read-only memory (CD-ROM), optical disc read / write, and DVD. The processor and program code used to implement each aspect of the present technology can be centralized or distributed (or a combination thereof) as known to those skilled in the art.

[0058] Although the present invention has been described in detail with reference to certain embodiments, it should be understood that the invention is not limited to those embodiments. In view of this disclosure, many modifications and variations will occur to those skilled in the art without departing from the scope of the various embodiments of the present invention as described herein. Therefore, the scope of the present invention is indicated by the appended claims rather than by the foregoing description. All changes, modifications and variations within the meaning and scope of the claims are considered to be within their scope. All advantageous embodiments claimed in the method claims may also apply to the system / device / apparatus claims.

Claims

1. A method for managing a simulation of an industrial system using heterogeneous processors, the method comprising generating at least one instance of a simulation model of the industrial system, the method being characterized by: generating a contiguous memory allocator from the heterogeneous processors to allocate a dynamic memory region within a first memory associated with a first processor, wherein: The simulation model is stored in the dynamic memory area within the first memory; generating the instance using the contiguous memory allocator for the dynamic memory region associated with a first processor of the heterogeneous processor, wherein generating the instance comprises providing, by the contiguous memory allocator, a dynamic allocation in response to a request for the instance, wherein the dynamic allocation is provided in the dynamic memory region; enabling a second processor of the heterogeneous processor to use the instance in the dynamic memory region based on a memory pointer associated with an address of the copy of the instance; and allocating a second memory associated with the second processor to a size of the first memory based on consumption of the first memory by the simulation model stored in the dynamic memory region; copying the first memory to the second memory based on the allocation, wherein a particular memory pointer instance points to the dynamic allocation in the second memory and thereby the simulation model is accessible to the second processor for execution; and simulating the industrial system by executing the simulation model copied to the second memory by the second processor, wherein the dynamic allocation is relatively referenced by a particular memory pointer instance, wherein the particular memory pointer instance is configured to determine its relative distance to the dynamic allocation, and wherein the memory pointer is generated using the particular memory pointer instance.

2. The method according to claim 1, further comprising: allocating a dynamic memory region accessible by the heterogeneous processor; creating a specific memory pointer instance with respect to the instance of the dynamic memory region; as well as The instance and copies of the instance are shared between the heterogeneous processors, wherein the address of the instance in the dynamic memory region is determined using the particular memory pointer instance.

3. The method according to any one of the preceding claims 1-2, further comprising: Initializing the instance on the first processor, wherein the instance is initialized to perform at least one function; and The initialized instance is referenced by the second processor using the memory pointer and the copy of the instance.

4. The method according to claim 3, further comprising: allocating the dynamic memory region to a first simulation application executed by the first processor, wherein the first simulation application generates the initialized instance; and The initialized instance is accessed by copying the dynamic memory region to the second memory associated with a second simulation application executed by the second processor, wherein the initialized instance is used by the second simulation application to simulate the industrial system.

5. The method according to claim 1, wherein: The heterogeneous processor includes at least one of a central processing unit and a graphics processing unit, wherein the first processor is the central processing unit and the second processor is the graphics processing unit, or vice versa.

6. The method according to claim 4, wherein: The industrial system is an autonomous vehicle, and wherein the simulation model includes an environmental model of an environment surrounding the autonomous vehicle, a physics-based model, and a predictive model for operating parameters of the autonomous vehicle.

7. The method according to claim 6, further comprising: generating a plurality of instances of the simulation model based on a plurality of configurations of the autonomous vehicle and a plurality of objects and object parameters in a vehicle environment, wherein the plurality of instances are generated by the first simulation application, wherein the plurality of configurations and the plurality of objects and object parameters are software libraries read by the first simulation application; dynamically allocating the plurality of instances within the dynamic memory region; copying the dynamic memory area to the second memory accessed by the second simulation application; jointly simulating the initialized instance by the second simulation application; and An optimal configuration of the autonomous vehicle is determined based on the joint simulation.

8. The method according to claim 1, wherein The industrial system is a turbine in an industrial plant, and wherein the simulation model includes physics-based functions and predictive functions to simulate operation of the turbine.

9. A computing platform for simulating an industrial system, the computing platform comprising: two or more heterogeneous processors, the two or more heterogeneous processors including a first processor and a second processor; a first memory associated with the first processor and a second memory associated with the second processor; and A memory allocation module configured to generating a contiguous memory allocator to allocate a dynamic memory region within the first memory, wherein a simulation model is stored in the dynamic memory region within the first memory, wherein the contiguous memory allocator is to provide dynamic allocations in response to requests from instances of the simulation model, wherein the dynamic allocations are provided in the dynamic memory region; and enabling a second processor of the heterogeneous processors to use the instance in the dynamic memory region based on a memory pointer associated with an address of the copy of the instance; allocating a second memory associated with the second processor to a size of the first memory based on consumption of the first memory by the simulation model stored in the dynamic memory area; copying the first memory to the second memory based on the allocation, wherein a particular memory pointer instance points to the dynamic allocation in the second memory and thereby the simulation model is accessible to the second processor for execution; and wherein the dynamic allocation is relatively referenced by a specific memory pointer instance, wherein the specific memory pointer instance is configured to determine its relative distance to the dynamic allocation, and wherein the memory pointer is generated using the specific memory pointer instance, wherein the second processor is capable of simulating the industrial system by executing the simulation model copied to the second memory.

10. The computing platform of claim 9, wherein: The heterogeneous processor includes at least one of a central processing unit and a graphics processing unit, wherein the first processor is the central processing unit and the second processor is the graphics processing unit.

11. A computer program product having machine-readable instructions stored therein, which, when executed by a computing platform according to claim 9 or claim 10, cause the computing platform to perform the method steps according to any one of claims 1 to 8.

Images