Patent Publication Number: US-10318668-B2

Title: Automatic decomposition of simulation model

Description:
TECHNICAL FIELD 
     The present disclosure relates to distributed simulation in general, and to automatic decomposition of simulation models, in particular. 
     BACKGROUND 
     A computer simulation is a computation that models the behavior of a system over time. Computer simulation consists in a set of techniques that are fundamental for the performance evaluation of existing systems. In some cases the computer simulation may be distributed simulation, i.e. a simulation in which more than one processor is employed. Distributed simulation may be efficient in faster obtaining of results, simulating larger scenarios, integrating simulators that are geographically distributed, composing different simulation models in a single simulator, or the like. 
     Distributed simulation techniques aim at an acceleration of the execution of simulation models by spatial decomposition and concurrent simulation of sub-models, using the concept of logical process, each one executing on a dedicated node of a multiprocessor system. 
     BRIEF SUMMARY 
     One exemplary embodiment of the disclosed subject matter is a computer-implemented method for decomposing a simulation model, the method comprising: obtaining the simulation model; automatically decomposing the simulation model into a predetermined number of co-simulation components, wherein each co-simulation component is allocated to a different simulation platform, wherein said automatically decomposing comprises: defining a target optimization function, wherein the target optimization function computes an estimated run time of the simulation model, wherein the target optimization function is based on a communication time within each co-simulation component and a communication time between each pair of co-simulation components; and determining a decomposition of the simulation model that optimizes a value of the target optimization function; and executing the decomposed simulation model by executing in parallel each co-simulation component on a different simulation platform, whereby the simulation model is executed in a distributed manner. 
     Another exemplary embodiment of the disclosed subject matter is a computerized apparatus having a processor, the processor being adapted to perform a method for decomposing a simulation model, the method comprising: obtaining the simulation model; automatically decomposing the simulation model into a predetermined number of co-simulation components, wherein each co-simulation component is allocated to a different simulation platform, wherein said automatically decomposing comprises: defining a target optimization function, wherein the target optimization function computes an estimated run time of the simulation model, wherein the target optimization function is based on a communication time within each co-simulation component and a communication time between each pair of co-simulation components; and determining a decomposition of the simulation model that optimizes a value of the target optimization function; and the method further comprises executing the decomposed simulation model by executing in parallel each co-simulation component on a different simulation platform, whereby the simulation model is executed in a distributed manner. 
     Yet another exemplary embodiment of the disclosed subject matter is a computer program product for decomposing a simulation model, the computer program product comprising a non-transitory computer readable storage medium retaining program instructions, which program instructions when read by a processor, cause the processor to perform a method comprising: obtaining the simulation model; automatically decomposing the simulation model into a predetermined number of co-simulation components, wherein each co-simulation component is allocated to a different simulation platform, wherein said automatically decomposing comprises: defining a target optimization function, wherein the target optimization function computes an estimated run time of the simulation model, wherein the target optimization function is based on a communication time within each co-simulation component and a communication time between each pair of co-simulation components; and determining a decomposition of the simulation model that optimizes a value of the target optimization function; and executing the decomposed simulation model by executing in parallel each co-simulation component on a different simulation platform, whereby the simulation model is executed in a distributed manner. 
    
    
     
       THE BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS 
       The present disclosed subject matter will be understood and appreciated more fully from the following detailed description taken in conjunction with the drawings in which corresponding or like numerals or characters indicate corresponding or like components. Unless indicated otherwise, the drawings provide exemplary embodiments or aspects of the disclosure and do not limit the scope of the disclosure. In the drawings: 
         FIGS. 1A and 1B  show schematic illustrations of a simulation model, in accordance with some exemplary embodiments of the subject matter; 
         FIGS. 2A and 2B  show flowchart diagrams of methods, in accordance with some exemplary embodiments of the subject matter; and 
         FIG. 3  shows a block diagram of an apparatus, in accordance with some exemplary embodiments of the disclosed subject matter. 
     
    
    
     DETAILED DESCRIPTION 
     One technical problem dealt with by the disclosed subject matter is to provide for performance improvement of simulated execution of a simulation model. Such improvement may be achieved by automatically decomposing the simulation model to co-simulation components. Each co-simulation component may be allocated to a different simulation platform. The different simulation platforms may be executed in concert to provide for a simulated execution of the simulation model. In some cases, however, the performance improvements may be dependent on the specific details of the decomposition of the simulation model. 
     In some exemplary embodiments, a simulation model may be a digital prototype of a physical model or a system. The simulation model may be used to predict performance of the physical model or the system in the real world. Simulation models may be used for optimizing geometry for weight and strength, selecting materials that meet weight, strength, and budget requirements, simulating part failure and identifying the loading conditions that cause them, assessing extreme environmental conditions or loads not easily tested on physical prototypes, such as earthquake shock load, verifying hand calculations, validating the likely safety and survival of a physical prototype, or the like. 
     In some exemplary embodiments, the simulation model may comprise processing elements. Each processing element may represent a part of the physical model or the system being simulated by the simulation model. Pairs of the processing elements may be connected by communication links. A communication link between a pair of processing elements may represent communication between the parts of the model or the system being simulated by the simulation model. In some cases, a communication link may be directional or non-directional. 
     As an example, a simulation model of a water molecule may comprise two processing elements representing the hydrogen atoms and one processing element representing the oxygen atom. Each hydrogen processing element may be connected to the oxygen processing element by a communication link. In some exemplary embodiments, the communication link between the hydrogen processing element and the oxygen processing element may have properties simulating properties of the chemical connection between the hydrogen atom and the oxygen atom within the water molecule. The simulation model of the water molecule may create a visual interpretation of H 2 O— the chemical representation of the water molecule. Water molecules can be viewed under powerful microscopes. The simulation model of the water molecule may be useful when trying to explain the core properties of the water molecule. 
     Another example may be a simulation model of a factory workflow. Each machine in the factory may be modeled as a processing element that takes a certain amount of time to create a particular part. The time to move parts between machines, the number of parts, the rate of moving the parts, or the time at which the raw material and the work orders come into the factory may be modeled by the communication links. Based on all these, the simulation model may determine whether the output of the factory meets the demand. Raw material coming into a factory may be approximated as coming in at fixed intervals. Computer simulators may apply realistic simulations by using scripts and codes similar to a real situation or even an exact recording of a real situation. 
     Another technical problem dealt with by the disclosed subject matter is protection of simulation model Intellectual Property (IP). In some cases, different component of a simulation model may have different IP levels. To protect components with high level of IP they might need to be executed on a separate server with corresponding protection protocols, which may be physically separated and protected or the like. 
     One technical solution is to decompose each simulation model into co-simulation components by defining a target optimization function that computes an estimated run time of the simulation model and determining a decomposition of the simulation model that maximizes the target optimization function. In some exemplary embodiments, the target optimization function may be based on a communication time within each co-simulation component and a communication time between each pair of co-simulation components. 
     In some exemplary embodiments, a set of processing elements may be selected for each co-simulation component. Each set processing elements may be allocated to a different simulation platform to be executed by the different simulation platform upon execution of the simulation model. 
     In some exemplary embodiments, the target optimization function that computes the estimated run time of the simulation model may be 
                 Max     ∀     c   i         ⁡     [     ET   ⁡     (     c   i     )       ]       +       Max     ∀     (       c   i     ,     c   j       )         ⁢       ⌊     CT   ⁡     (       c   i     ⁢     c   j       )       ⌋     .             
c i  may be a co-simulation component of the decomposed model. ET(c i ) may be an execution time of the co-simulation component c i . In some exemplary embodiments, the execution time of the co-simulation component may be a summation of the execution time of each processing element comprised by the co-simulation component and a communication time of each communication link within the co-simulation component (e.g., intra-component communication time). (c i ,c j ) may be a pair of co-simulation components, c i  and c j , selected from the decomposed simulation model. CT(c i ,c j ) may be a communication time between the pair of co-simulation components. In some exemplary embodiments, the communication time between the pair of co-simulation components may be computed based on communication time of each communication link in between the pair of co-simulation components (e.g., inter-components communication time). Communication links in between a pair of co-simulation components may be communication link that connects a processing element from the first co-simulation component with a processing element from the second co-simulation elements. It will be noted that in some embodiments, intra-component communication may be more efficient than inter-component communication time. Additionally or alternatively, intra-component communication time may be significantly lower than inter-components communication time for a same amount of communication data.
 
     Another technical solution is to decompose the simulation model into co-simulation components based on a property of the simulation model. In some exemplary embodiments, the property of the simulation model may be a computational power of each simulation platform, a latency between each pair of simulation platform, a security level of each simulation platform, or the like. Additionally or alternatively, the decomposition of the simulation model into co-simulation components may be determined based on a property of a simulation platform. In some exemplary embodiments, the property of the simulation platform may a minimal security level of a simulation platform that is used to execute a processing element, a performance requirement of executing the simulation model, or the like. 
     Properties of the simulation models may include, but are not limited to, type and number of communication links between processing elements of the simulation model, response time of processing elements, computational complexity of processing elements, IP level of processing elements. 
     Properties of the simulation platforms may include, but are not limited to, the number of distributed simulation platforms and their computation power (such as memory, number of cores, or the like), latency between simulation platforms, Security level of simulation platforms. In some exemplary embodiments, the properties may be provided by a user, be discovered by an analysis of the simulation platforms, such as by performing profiling or other dynamic analysis method during execution of the simulation platforms, or the like. 
     In some exemplary embodiments, the decomposition of the simulation model may be performed while taking into account a set of constraints, such as a constraint resulting from the property of the simulation model, a constraint resulting from the property of the simulation platforms, or the like. As an example, the simulation model may be decomposed according to a constraint resulting from performance requirements of the simulation model (e.g., Service Level Agreement (SLA) requirement for performing a function), a constraint resulting from security requirements of the simulation model (e.g., IP protection requirement), or the like. 
     In some exemplary embodiments, each co-simulation component may be wrapped with a co-simulation wrapper for providing API to and from the co-simulation component, such as High-Level Architecture (HLA), Functional Mock-up Interface (FMI), or the like. Additionally or alternatively, each co-simulation component may be deployed as a distributed simulation. 
     In some exemplary embodiments, static analysis of the simulation model may be performed to determine the property of simulation model. Additionally or alternatively, dynamic analysis, such as profiling, of the simulation platform may be performed while the simulation model is being executed to determine the property of the simulation platform. 
     One technical effect of the disclosed subject matter is to execute simulation models on a plurality of simulation platforms simultaneously, while potentially minimizing the monetary cost. The disclosed subject matter may provide for an automatic manner of decomposition of simulation models and execution of the decomposed simulation models on different simulation platforms without requiring specific human design, costly design phase and high maintenance costs. Additionally or alternatively, the disclosed subject matter automatically takes into account constraints related to the simulation models, properties of the simulation platforms, or the like. Additionally or alternatively, embodiments of the disclosed subject matter may reduce the effort involved in establishing a performance and privacy-maintaining deployment of the simulation models. Additionally or alternatively, embodiments of the disclosed subject matter may reduce the manual effort that is required for a proper decomposition of models that is time consuming, error-prone and hard for adoption of models modification. 
     One technical solution is to decompose each simulation model into co-simulation components by defining a target optimization function that computes an estimated run time of the simulation model and determining a decomposition of the simulation model that maximizes the target optimization function. In some exemplary embodiments, the target optimization function may be based on a communication time within each co-simulation component and a communication time between each pair of co-simulation components. 
     Referring now to  FIG. 1A  showing a schematic illustration of a simulation model, in accordance with some exemplary embodiments of the subject matter. 
     In some exemplary embodiments, a Simulation Model  100  may be a computational model that is used to simulate a physical object, system or the like, hereinafter referred to for simplicity as the physical object. Simulation Model  100  may predict functionality, performance, operation, or the like of the physical object in the real world. Simulation Model  100  may provide information about how the physical object is expected to behave. In some exemplary embodiments, using Simulation Model  100  may provide for expected outcomes of the physical object&#39;s functionality and interaction with other objects, without having to test the physical object itself. 
     In some exemplary embodiments, Simulation Model  100  may comprise processing elements, such as Processing Element e 1    111 , Processing Element e 2    112 , Processing Element e 3    113 , Processing Element e 4    114  and Processing Element e 5    115 . Processing Elements  111 ,  112 ,  113 ,  114 ,  115  may be computational elements simulating units of the physical object simulated by Simulation Model  100 . In some exemplary embodiments, the units may be processing units, sub-units of the physical object, or the like. 
     In some exemplary embodiments, Simulation Model  100  may comprise communication links between the processing elements, such as Communication Link (e 1 ,e 2 )  121 , Communication Link (e 1 ,e 3 )  122 , Communication Link (e 2 ,e 3 )  123 , Communication Link (e 2 ,e 4 )  124 , and Communication Link (e 2 ,e 5 )  125 . The communication links may represent communications between units, such as data from one unit may affect functionality of another object. In some exemplary embodiments, the communication link is directional and may indicate communication flow from one unit to another. Additionally or alternatively, the communication link may be unidirectional and may indicate data flows in both directions of the communication link. 
     In some exemplary embodiments, each processing element may have an associated effective processing time p n  per simulation step. The effective processing time may be derived from the computational complexity of the processing elements, number of cores, or the like. Each communication link (e i ,e j ) may have an associated average communication time per step, s ij , representing the average communication time when both processing elements connected by the link are being executed on the same simulation platform; and an associated average communication time between simulation platforms per step, t ij , representing the average communication time of the link when each processing elements connected by the link is being executed on a different simulation platform. In some exemplary embodiments, it may be expected that s ij  may be significantly smaller than t ij  (s ij &lt;&lt;t ij ). 
     Referring now to  FIG. 1B  showing a schematic illustration of a possible decomposition of a simulation model, in accordance with some exemplary embodiments of the subject matter. 
     In some exemplary embodiments, Simulation Model  100  may be decomposed into two co-simulation components: Simulation Component  110  and Simulation Component  120 . 
     In some exemplary embodiments, a target optimization function may be defined and used so as to automatically determine a suggested decomposition. The target optimization function may compute the estimated run time of Simulation Model  100  as decomposed. In some exemplary embodiments, minimizing the target optimization function may result in a decomposition that is associated with a minimal estimated run time. Additionally or alternatively, other cost metrics may be minimized in addition to or instead of overall estimated run time. 
     In some exemplary embodiments, The target optimization function may be computed as: 
                   Max     ∀     c   i         ⁡     [     ET   ⁡     (     c   i     )       ]       +       Max     ∀     (       c   i     ,     c   j       )         ⁢     ⌊     CT   ⁡     (       c   i     ⁢     c   j       )       ⌋         ,         
where c i  may be a co-simulation component of the decomposed model, ET( ) may be an execution time of the co-simulation component; In some exemplary embodiments, the execution time of the co-simulation component may be a summation of the execution time of each processing element comprised by the co-simulation component and a communication time of each communication link within the co-simulation component (e.g., intra-component communication time). (c i ,c j ) may be a pair of co-simulation components, c i  and c j , selected from the decomposed simulation model. CT( ) may be a communication time between the pair of co-simulation components. In some exemplary embodiments, the communication time between the pair of co-simulation components may be computed based on communication time of each communication link in between the pair of co-simulation components (e.g., inter-components communication time).
 
     In some exemplary embodiments, each potential decomposition of Simulation Model  100  may be associated with a value for the target optimization function. A decomposition having a minimal value, a value below a threshold, or the like, may be selected as an automatically suggested decomposition. In some exemplary embodiments, only decomposition models that hold certain constraints, such as IP security level constraint, may be examined as potentially acceptable decompositions of the model. 
     As an example.  FIG. 1B  depicts a suggested decomposition of Simulation Model  100  where Simulation Component  110  comprises Processing Element e 1    111  and Processing Element e 3    113 , and where Simulation Component  120  comprises Processing Element e 2    112 , Processing Element e 4    114  and Processing Element e 5    115 . Accordingly, Communication Link  121  is within Simulation Component  110 , Communication Links  124  and  125  are within Simulation Component  120  (i.e., intra-component link), while Communication Links  122  and  123  are in between within Simulation Component  110  and Simulation Component  120  (i.e., inter-components links). 
     In such suggested decomposition, the target optimization function may be computed as: Max[ET(c 1 ),ET(c 2 )]+Max[CT(c 1 ,c 2 )], where c 1  may represent Simulation Component  110  and c 2  may represent Simulation Component  120 . Accordingly, the target optimization function may be computed as: Max[(p 1 +p 3 +s 13 ),(p 2 +p 4 +p 5 +s 24 +s 25 )]+Max[t 12 +t 23 ]. 
     Referring now to  FIG. 2A  showing a flowchart diagram of a method, in accordance with some exemplary embodiments of the subject matter. 
     In Step  210 , a simulation model may be obtained. In some exemplary embodiments, the simulation model may comprise processing elements and communication links between pairs of processing elements. The processing elements may be computational elements simulating units of the physical object. In some exemplary embodiments, the simulation model may be provided in computer-readable form, such as retained in a non-transitory computer readable medium. 
     In Step  220 , the simulation model may be decomposed into a predetermined number of co-simulation components. In some exemplary embodiments, the decomposition may be performed automatically or semi-automatically. 
     In Step  223 , each co-simulation component may be allocated to a different simulation platform. In some exemplary embodiments, a number of available simulation platforms may be a limit as to the number of potential co-simulation components to decompose the model into. 
     In Step  225 , a target optimization function may be defined. The target optimization function may compute an estimated run time of the simulation model as decomposed into the predetermined number of co-simulation components. In some exemplary embodiments, the target optimization function may be based on a communication time within each co-simulation component and a communication time between each pair of co-simulation components. Additionally or alternatively, the target optimization function may be associated with monetary cost of execution, such as for example, in case CPU resources are associated with a monetary cost which may differ from one platform to the other. Additionally or alternatively, other cost metrics may be used as a metric to be optimized by the target optimization functions. 
     In Step  226 , a decomposition of the simulation model that minimizes the target optimization function may be determined. Additionally or alternatively, the target decomposition may be a decomposition that provides a best value to the target optimization function (e.g., minimal value, as may be the case with execution time, maximal value, as may be the case with quality level, or the like). Additionally or alternatively, the target decomposition may provide a sufficiently good and not necessarily optimal decomposition, such as a value below a minimal threshold, above a maximal threshold, or the like. In the present disclosure, the target optimization function is said to be “optimized” in case an optimal value or a sufficiently good value is obtained. In some exemplary embodiments, in Step  226 , each potential decomposition of the simulation model may be reviewed and the value of the target optimization function may be computed. In some exemplary embodiments, brute force enumeration methods may be used to identify the decomposition providing optimal value for the target optimization function. Additionally or alternatively, heuristic approaches, approximations, or the like may be used to enhance efficiency of the search of the potential decomposition spaces, instead of simple brute force enumeration. 
     In Step  227 , processing elements may be assigned to different co-simulation components in accordance with the determined optimal decomposition. As a result, the optimal decomposition may be implemented. 
     In Step  250 , each co-simulation component may be executed on the different simulation platform. The co-simulation components may be executed in parallel, thereby providing for distributed simulation of the original, non-distributed, simulation model. 
     Referring now to  FIG. 2B  showing a flowchart diagram of a method in accordance with some exemplary embodiments of the subject matter. 
     In Step  220 , the simulation model may be decomposed into a predetermined number of co-simulation components. Additionally or alternatively, a decomposition of the simulation model may be determined taking into account a set of constraints. The set of constraints may comprise one or more constraints resulting from the property of the simulation model, one or more constraints resulting from the property of the simulation platforms, or the like. In some exemplary embodiments, such properties may affect the target optimization function in addition to or instead of being related to constraints. 
     In Step  221 , a static analysis of the simulation model may be performed to identify properties of the simulation model. In some exemplary embodiments, the properties of the simulation model may comprise a minimal security level of a simulation platform that is used to execute a processing element, a performance requirement of executing the simulation model or a processing entity or other portions thereof, or the like. 
     In Step  222 , a dynamic profiling of the simulation platforms may be performed to determine one or more properties of each simulation platform. In some exemplary embodiments, the properties of a simulation platform may comprise a computational power of each simulation platform, a latency during communication between each pair of simulation platform, a security level of each simulation platform, or the like. 
     Referring now to  FIG. 3  showing a block diagram of an apparatus in accordance with some exemplary embodiments of the disclosed subject matter. 
     In some exemplary embodiments, Apparatus  300  may comprise one or more Processor(s)  302 . Processor  302  may be a Central Processing Unit (CPU), a microprocessor, an electronic circuit, an Integrated Circuit (IC) or the like. Processor  302  may be utilized to perform computations required by Apparatus  300  or any of it subcomponents. 
     In some exemplary embodiments of the disclosed subject matter, Apparatus  300  may comprise an Input/Output (I/O) Module  305 . Apparatus  300  may utilize I/O Module  305  as an interface to transmit and/or receive information and instructions between Apparatus  300  and external I/O devices, such as a Workstation  397 , a Computing Device (not shown), or the like. In some exemplary embodiments, I/O Module  305  may provide an interface to a system or a physical model or an interface of a simulation model, and may be useful for instructing a simulation platform to execute a processing element, thereby executing a decomposition of a simulation model determined by Apparatus  300 . 
     In some exemplary embodiments, I/O Module  305  may be used to provide an interface to a User  395  of the system, such as by providing output, outcome of simulation model decomposition, or the like. User  395  may use Workstation  397  to input a simulation model to be decomposed and executed on a plurality of simulation platforms. In some exemplary embodiments, the simulation model provided by I/O Module  305  may comprise processing elements and communication links between pairs of processing elements. In some exemplary embodiments, User  395  may provide user input indicating which constraints of the simulation model parts are restricted and to which simulation platform, indicate which processing elements of the simulation model are confidential and restricted, or the like. It will be appreciated that Apparatus  300  can operate without human operation. 
     In some exemplary embodiments, Apparatus  300  may comprise a Memory Unit  307 . Memory Unit  307  may be a hard disk drive, a Flash disk, a Random Access Memory (RAM), a memory chip, or the like. In some exemplary embodiments, Memory Unit  307  may retain program code operative to cause Processor  302  to perform acts associated with any of the subcomponents of Apparatus  300 . 
     In some exemplary embodiments, Memory Unit  307  may comprise a Decomposition Module  310 . Decomposition Module  310  may be configured to automatically decompose a simulation model obtained by I/O Module into no more than a predetermined number of co-simulation components. Decomposition Module  310  may allocate each co-simulation component to a different simulation platform. In some exemplary embodiments, Decomposition Module  310  may be configured to determine for each co-simulation component, a set of one or more processing elements. Decomposition Module  310  may be configured to allocate each set of one or more processing elements to a different simulation platform to be executed by the different simulation platform upon execution of the simulation model by an Execution Module  360 . 
     In some exemplary embodiments, Decomposition Module  310  may be configured to determine a decomposition of the simulation model that maximizes a target optimization function defined by a Target Optimization Function Module  320 . 
     Target Optimization Function Module  320  may be configured to define a target optimization function that computes an estimated run time of the simulation model. In some exemplary embodiments, Target Optimization Function Module  320  may be configured to define the target optimization function based on a communication time within each co-simulation component of the simulation model and a communication time between each pair of co-simulation components. 
     In some exemplary embodiments, Target Optimization Function Module  320  may be configured to define a target optimization function as a summation of the maximal execution time of a co-simulation component selected from the co-simulation components determined by Decomposition Module  310  and the maximal communication time between a pair of co-simulation components. In some exemplary embodiments, the execution time of a co-simulation component may comprises a summation of the execution time of each processing element comprised by the co-simulation component and a communication time of each communication link connecting processing elements within the co-simulation component. In some exemplary embodiments, the communication time between each pair of co-simulation components may be computed based on communication time of each communication link that connects a pair of co-simulation components being allocated to different simulation platforms. 
     In some exemplary embodiments, Decomposition Module  310  may be configured to determine a decomposition of a simulation model based on a property of the simulation model. Additionally or alternatively, Decomposition Module  310  may be configured to determine a decomposition of a simulation model based on a property of the simulation platforms the de-composed model is being allocated to. 
     Additionally or alternatively, Decomposition Module  310  may be configured to determine a decomposition of the simulation model taking into account a set of constraints. The set of constraints may comprise a constraint resulting from the property of the simulation model and a constraint resulting from the property of the simulation platforms. 
     In some exemplary embodiments, Memory Unit  307  may comprise a Simulation Models Analysis Module  340 . Simulation Models Analysis Module  340  may be configured to perform static analysis of the simulation model being analyzed by Decomposition Module  310  to determine the property of simulation model. 
     In some exemplary embodiments, Memory Unit  307  may comprise a Simulation Platform Profiling Module  350 . Simulation Platform Profiling Module  350  may be configured to perform profiling of a simulation platform that a co-simulation component is being allocated to, to determine the property of the simulation platform. 
     In some exemplary embodiments, Memory Unit  307  may comprise an Execution Module  360 . Execution Module  360  may be configured to execute co-simulation components determined by Decomposition Module  310 . Execution Module  360  may be configured to execute processing elements comprised by each co-simulation by a different simulation platform. 
     An Embodiment 
     The following provides an illustrative non-limiting concrete embodiment of the disclosed subject matter. 
     In a simulation model there are 5 simulation tasks. The simulation system comprises 5 servers dedicated for simulation (e.g., simulation platforms). Tasks 1 and 3 of the model are required to be executed by “secure” servers (also referred to as secure tasks). Servers 1 and 2 are the only secure servers in the simulation system. Execution time of the task depends also on server power and given as server rate. Communication time between tasks allocated on the same server also depends on server power. Communication time between tasks on different servers depends on inter-server link bandwidth and given as inter-server link rate. Secure link between tasks should be allocated either to secure server or to secure inter-server link. 
     An optimization model using the Optimization Programming Language (OPL) may be provided as follows: 
     
       
         
           
               
             
               
                   
               
             
            
               
                 {int} tasks = ...; 
               
               
                 float procTimes[t in tasks] = ...; 
               
               
                 {int} secTasks = ...; 
               
               
                 tuple Link { 
               
               
                   int t1; 
               
               
                   int t2; 
               
               
                   float intTime; //if tasks in the same server; 
               
               
                   float extTime; //if tasks in different servers; 
               
               
                   int isSecure; 
               
               
                 }; 
               
               
                 {Link} links =...; 
               
               
                 {int} servers = ...; 
               
               
                 {int} secServers = ...; 
               
               
                 tuple ServerLink { 
               
               
                   int s1; 
               
               
                   int s2; 
               
               
                   float interSeverLinkRate; 
               
               
                   int isSecure; 
               
               
                 }; 
               
               
                 {ServerLink} sLinks =...; 
               
               
                 float serverRate[s in servers] =...; 
               
               
                 dvar boolean task2server[t in tasks][s in servers]; 
               
               
                 dvar float+ link2ss[l in links][s1 in servers][s2 in servers]; 
               
               
                 dvar float serverTime[s in servers]; 
               
               
                 dvar float interServerTime[sLinks]; 
               
               
                 dvar float maxServerTime; 
               
               
                 dvar float maxInterServerTime; 
               
               
                 minimize maxServerTime + maxInterServerTime; 
               
               
                 subject to { 
               
               
                   forall(s in servers) maxServerTime &gt;= serverTime[s] * 
               
               
                 serverRate[s]; 
               
               
                   forall(L in sLinks) maxInterServerTime &gt;= 
               
               
                 InterServerTime[L] * L.interSeverLinkRate; 
               
               
                   forall(L in sLinks: L.s1 == L.s2) interServerTime[L] == 0; //for 
               
               
                 faster processing 
               
               
                   forall(s in servers) serverTime[s] == sum(t in tasks) 
               
               
                 procTimes[t] * task2server[t][s] + sum(L in links) link2ss[L][s][s] * 
               
               
                 L.intTime; 
               
               
                   forall(sL in sLinks: sL.s1 != sL.s2) 
               
               
                 interServerTime[sL] == sum(L in links) 
               
               
                 link2ss[L][sL.s1][sL.s2] * L.extTime; 
               
               
                   forall(s1, s2 in servers: s1 != s2, l in links) 
               
               
                 link2ss[l][s1][s2] &gt;= task2server[l.t1][s1] + task2server[l.t2][s1] + 
               
               
                 task2server[l.t1][s2] + task2server[l.t2][s2] − 1; 
               
               
                   forall(s1, s2 in servers: s1 != s2, l in links) 
               
               
                 link2ss[l][s1][s2] &lt;= task2server[l.t1][s1] + task2server[l.t2][s1]; 
               
               
                   forall(s1, s2 in servers: s1 != s2, l in links) 
               
               
                 link2ss[l][s1][s2] &lt;= task2server[l.t1][s2] + task2server[l.t2][s2]; 
               
               
                   forall(s1 in servers, l in links) link2ss[l][s1][s1] &gt;= 
               
               
                 task2server[l.t1][s1] + task2server[l.t2][s1] − 1; 
               
               
                   forall(s1 in servers, l in links) link2ss[l][s1][s1] &lt;= 
               
               
                 task2server[l.t1][s1]; 
               
               
                   forall(s1 in servers, l in links) link2ss[l][s1][s1] &lt;= 
               
               
                 task2server[l.t2][s1]; 
               
               
                   forall(t in tasks diff secTasks) sum(s in servers) 
               
               
                 task2server[t][s] == 1; // each task should be allocated to server 
               
               
                   forall(t in secTasks) sum(s in secServers) task2server[t][s] == 
               
               
                 1; // each secure task should be allocated to secure server 
               
               
                   forall(L in links: L.isSecure == 1) sum(sL in sLinks: 
               
               
                 sL.isSecure == 0) link2ss[L][sL.s1][sL.s2] == 0; // secure Link should 
               
               
                 NOT be allocated to unsecure link 
               
               
                   forall(L in links: L.isSecure == 1) sum(s1 in servers 
               
               
                 diff secServers) link2ss[L][s1][s1] == 0;  // secure link should 
               
               
                 NOT be allocated to unsecure server 
               
               
                 } 
               
               
                   
               
            
           
         
       
     
     The OPL data file may be as follows: 
     
       
         
           
               
               
             
               
                   
                   
               
             
            
               
                   
                 tasks = {1,2,3,4,5}; 
               
               
                   
                 servers = {1,2,3,4,5}; 
               
               
                   
                 links = { 
               
               
                   
                  &lt;1,2,0.01,2,0&gt; 
               
               
                   
                  &lt;1,3,1,20,1&gt; 
               
               
                   
                  &lt;2,3,0.1,2,0&gt; 
               
               
                   
                  &lt;2,4,0.1,5,0&gt; 
               
               
                   
                  &lt;2,5,0.01,2,0&gt; 
               
               
                   
                  }; 
               
               
                   
                  sLinks = { 
               
               
                   
                   &lt;1,2,1,1&gt; 
               
               
                   
                   &lt;1,3,5,0&gt; 
               
               
                   
                   &lt;1,4,5,0&gt; 
               
               
                   
                   &lt;1,5,20,0&gt; 
               
               
                   
                   &lt;2,3,5,0&gt; 
               
               
                   
                   &lt;2,4,5,0&gt; 
               
               
                   
                   &lt;2,5,20,0&gt; 
               
               
                   
                   &lt;3,4,1,1&gt; 
               
               
                   
                   &lt;3,5,5,0&gt; 
               
               
                   
                   &lt;4,5,5,0&gt; 
               
               
                   
                   }; 
               
               
                   
                 serverRate = [ 1.8 1 1.3 1.5 1.5 ]; 
               
               
                   
                 procTimes = [ 15 21 23 35 11 ]; 
               
               
                   
                 secTasks = {1, 3}; 
               
               
                   
                 secServers = {1, 2}; 
               
               
                   
                   
               
            
           
         
       
     
     As an example, a solution to the above example may be automatic decomposition of the model so that task 3 is allocated to server 1, tasks 1 and 5 are allocated to server 2, task 4 is allocated to server 3, and task 2 is allocated to server 4. Server 5 remains unused. Such decomposition provides a maximum server time of 45.5 and maximum inter-server time of 20. Total processing time is therefore 65.5 which is an optimal processing time given the constraints of the model and the properties of the simulation system. 
     The present invention may be a system, a method, and/or a computer program product. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention. 
     The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire. 
     Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device. 
     Computer readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C++ or the like, and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The computer readable program instructions may execute entirely on the user&#39;s computer, partly on the user&#39;s computer, as a stand-alone software package, partly on the user&#39;s computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user&#39;s computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention. 
     Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions. 
     These computer readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks. 
     The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks. 
     The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions. 
     The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used herein, the singular forms “a”, “an” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. 
     The corresponding structures, materials, acts, and equivalents of all means or step plus function elements in the claims below are intended to include any structure, material, or act for performing the function in combination with other claimed elements as specifically claimed. The description of the present invention has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the invention. The embodiment was chosen and described in order to best explain the principles of the invention and the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated.