Alternative Solutions To Sim Cloning

SIMULATION
http://sim.sagepub.com Alternative Solutions for Distributed Simulation Cloning

Dan Chen, Stephen John Turner, Boon Ping Gan, Wentong Cai, Junhu Wei and Nirupam Julka SIMULATION 2003; 79; 299 DOI: 10.1177/0037549703037147 The online version of this article can be found at: http://sim.sagepub.com/cgi/content/abstract/79/5-6/299
Published by:
http://www.sagepublications.com
On behalf of:
Society for Modeling and Simulation International (SCS)
Additional services and information for SIMULATION can be found at: Email Alerts: http://sim.sagepub.com/cgi/alerts Subscriptions: http://sim.sagepub.com/subscriptions Reprints: http://www.sagepub.com/journalsReprints.nav Permissions: http://www.sagepub.com/journalsPermissions.nav
Downloaded from http://sim.sagepub.com at PENNSYLVANIA STATE UNIV on April 15, 2008 2003 Simulation Councils Inc.. All rights reserved. Not for commercial use or unauthorized distribution.
Alternative Solutions for Distributed Simulation Cloning

Dan Chen Singapore Institute of Manufacturing Technology Singapore 638075 dchen@simtech.a-star.edu.sg Stephen John Turner School of Computer Engineering Nanyang Technological University Singapore 639798 Boon Ping Gan Singapore Institute of Manufacturing Technology Singapore 638075 Wentong Cai Junhu Wei School of Computer Engineering Nanyang Technological University Singapore 639798 Nirupam Julka Singapore Institute of Manufacturing Technology Singapore 638075 Simulation cloning is designed to satisfy the requirement of examining alternative scenarios concurrently. This article discusses the issues involved in cloning distributed simulations based on the High Level Architecture (HLA) and proposes tentative solutions. Alternative solutions are compared from both the qualitative and quantitative point of view. In terms of federation organization, candidate solutions can be classied into the single-federation and the multiple-federation categories. To guarantee the correctness and optimize the performance of the whole cloning-enabled distributed simulation, the single-federation solution requires an additional mechanism to isolate the interactions among alternative executions. Data distribution management (DDM) is one of the candidate approaches. To measure the trade-off between complexity and efciency, the authors introduce a series of experiments to benchmark various solutions at the runtime infrastructure (RTI) level. The benchmark results indicate that the single-federation solution provides encouraging performance when using DDM. Keywords: Simulation cloning, HLA, RTI, single federation, multiple federation, data distribution management
1. Introduction Distributed simulation is an important technology that enables a simulation program to be executed on a distributed computer system. A large-scale simulation may be constructed by linking together existing simulation models at possibly different locations to form a simulation
SIMULATION, Vol. 79, Issue 56, MayJune 2003 299-315 2003 The Society for Modeling and Simulation International DOI: 10.1177/003754903037147
| | | |
federation. The main applications of distributed simulation include military applications, entertainment, social interactions and business collaborations, education and training, and so forth. Distributed simulation technology also meets the pressing need of supply chain simulation, as a supply chain often involves multiple companies across enterprise boundaries [1, 2]. The High Level Architecture (HLA) denes the rules and specications to support reusability and interoperability among the simulation components (federates). One
Chen et al.
federate is able to interact with different federates using the runtime infrastructure (RTI) [3]. However, in a normal analytic distributed simulation, the output reports one single set of results per simulation. To optimize the simulated system or perform what-if analysis, one should repeat the simulation multiple times to examine alternative scenarios, decision policies, and strategies using different decision rules and parameters. Subsequently, the best solutions may be selected based on all the possible results. Basically it is a time-consuming and onerous task. When a federate reaches a decision point, it is faced with multiple different choices. The cloning approach offers users the exibility to examine the different choices concurrently, rather than executing them one by one in a deterministic or random way. At the decision point, the federate can replicate itself into multiple copies (clones) to explore each possibility. Each clone explores one particular path together with its partner clones spawned from the other federates in the original scenario. From an individual clones point of view, it merely interacts with its partners to form an independent scenario. This provides the user with the opportunity to evaluate multiple alternative results concurrently using the same simulation run. A further consideration is that simulation components running at different locations are liable to failure. It may be possible to use the replication mechanisms for cloning to achieve fault tolerance. If one scenario encounters failure, the remaining concurrent scenarios are still able to continue execution. One of the key benets of HLA-based simulation is reusability [4]. It means the component simulation models can be reused in different simulation scenarios and applications. A middleware approach is introduced to hide the implementation of the cloning mechanism and still provide users with the standard RTI interface. The middleware is located between the user federate and the real RTI and encapsulates modules for cloning and simulation control. Thus, the complexity incurred by cloning is hidden from the users. When generating a new clone, alternative solutions may be adopted. The clone may persist in the original federation or form a new federation together with its partners. To keep the correctness of the execution in various paths, one should apply some mechanism to isolate the interactions among clones in different execution paths. In other words, logically, one clone will only interact with its partners, which are the corresponding clones of other federates. In a single federation, this may be achieved either by tagging the interactions or by using data distribution management (DDM) [4]. To investigate the overhead incurred by cloning, this article presents a set of benchmark experiments to examine the execution time of given distributed simulations using the different solutions. The experiments explore the impact on the execution time of both message transmission and synchronization. A shorter version of this article was presented at the 36th
Annual Simulation Symposium [5]. This extended article also discusses two DDM solutions introduced for scenario management, as well as clone and scenario identication [6]. A recursive region division solution and a point region solution are discussed and compared. The former solution initializes each original federate with a region occupying the full dimension of the routing space. During the cloning procedure, the new clones inherit split subregions from their parent. The latter solution species a point region for each original federate, and a new clone is given an additional point region on birth. Shared clones may have changing region combinations when cloning occurs in the scenarios in which they operate. Finally, this article also presents how the mechanism may be implemented using a middleware method to address reusability issues. In this method, scenario manager and region manager modules are developed to support both cloning execution and extensions to the RTI. Our proposed middleware approach offers transparency in adding scenario management to the users federates. The rest of this article is organized as follows: distributed simulation cloning technology and related work are addressed in section 2. Section 3 covers the alternative solutions in detail. Section 4 introduces the design of the experiments and analyzes the benchmark results. Section 5 studies the issues related to managing concurrent scenarios and gives the two region management solutions. In section 6, we conclude with a summary and proposals on future works. 2. Distributed Simulation Cloning 2.1 Related Work Hybinette and Fujimoto [7] proposed simulation cloning in the context of parallel simulation. The motivation for this technique was to develop a parallel model that supports an efcient, simple, and effective way to evaluate and compare alternate scenarios. The method was targeted for parallel discrete event simulators that provide the simulation application developer with a logical process (LP) execution model. Schulze, Straburger, and Klein [8] introduced a cloning approach to extend the exibility of system composition to runtime. Their approach included the parallel management of different time axes to provide forecast functionality. Internal cloning and external cloning techniques were suggested to clone the federates at runtime. As our design targets potential industry users who may have their own existing complex simulation models, we have the additional aim to provide reusability and transparency while enabling simulation cloning. Providing easy utilization and deployment is another major concern. Distributed simulation cloning technology should be a much more powerful and exible decision support tool than traditional linear simulation.
300 SIMULATION Volume 79, Number 56
ALTERNATIVE SOLUTIONS FOR DISTRIBUTED SIMULATION CLONING
2.2 Issues in Simulation Cloning 2.2.1 Decision Points During the execution of a simulation, a federate may face different choices to perform alternative actions. The federate is cloned at such decision points according to some rules. A decision point represents the location in the execution path where the states of the system start to diverge in a cloning-enabled simulation. Cloning differs from simple replication in the sense that clones of the original federate execute in different paths rather than simply repeat the same executions, even though the computation of clones is identical at the decision point. From the decision point onwards, a simulation spawns multiple executions to exploit alternative scenarios concurrently. For example, in a simple manufacturing simulation illustrated in Figure 1, a batch machine is processing a lot while some lots are waiting in a queue. In this gure, part (A) gives the manufacturing process, and part (B) indicates the advancing of the simulation. When the current job nishes, the machine status changes from busy to idle. If it is found that the queue length has become greater than the alert level, one needs to use some special dispatching rule to process the waiting lots. The time and cost to be consumed may vary for different rules. Instead of simulating all the three possibilities from the start, it is possible to clone two more executions to examine the rules of interest concurrently once the condition QUEUE_LENGTH_GREATER_ALERT is met. The point where the queue length reaches the alert level and the machine becomes idle is one decision point in this simulation. From the users point of view, decision points can be specied either at the modeling stage or at runtime. At the modeling stage, the user can specify the conditions of the decision points, as well as the policies and rules for the decision points. During runtime, the user can insert decision points dynamically and can even specify alternative execution paths at a decision point interactively. 2.2.2 Active and Passive Cloning of Federates When a federate reaches a decision point, it makes clones on its own initiative. This federate is said to perform active cloning. Each clone of the federate executes a separate scenario. In distributed simulations, there are multiple federates interoperating with each other. When one federate splits into different executions, the partners that interact with this federate may have to spawn clones to perform proper interaction, even though the partners have not yet met a decision point. Those partners are said to perform passive cloning. Generally speaking, the clones generated in an active cloning have separate initial states while those created in a passive cloning have identical initial states. Only the active cloning leads to the creation of new scenarios, and this induces passive cloning in some other federates.
Queue Length > alert level ?
IDLE Batch Machine BUSY
Lot Queue
Multiple dispatch rules
(A)
FIFO
Decison Point
FILO
Rando m
(B)
Figure 1. A simple manufacturing simulation. FIFO = rst in, rst out; FILO = rst in, last out.
2.2.3 Entire versus Incremental Cloning A simple approach to keep the correctness of the simulation is to clone the whole simulation whenever any federate reaches a decision point (i.e., entire cloning). Each cloned simulation consists of a separate set of federates that report results independently. One can see that the scalability of distributed simulation is a challenge in this case. Another approach replicates the simulation incrementally (i.e., only those federates whose states will alter at a decision point need to be cloned; other federates will remain intact). Such an incremental cloning approach shares computation between federates in alternative scenarios and provides a more efcient and scalable method to clone the distributed simulation. 2.2.4 Shared Clones In some cases, a federate does not need to perform passive cloning when its partner clones actively. Although new scenarios have been created due to the active cloning, one clone is capable of executing in multiple scenarios. In this article, we name such clones as shared clones. A shared clone may subsequently perform cloning passively during the execution of the simulation on demand of its partners. 3. Alternative Solutions for Cloning in HLA-Based Distributed Simulation When a federate is cloned, we can create multiple federations to meet the demand of executing alternative scenarios
Volume 79, Number 56 SIMULATION 301
Chen et al.
or generate new federates to operate in the original federation without intervening in the execution of any other scenario. This article refers to the multiple-federation solution (MF) to denote the former design and the single-federation solution (SF) to denote the latter one. 3.1 Single-Federation Solution versus Multiple-Federation Solution Figure 2 depicts the cloning of a simulation using both solutions. Federates inside the dashed rectangle represent the clones originating from a common ancestor. Following the cloning action that is triggered at the decision point, both original federates (A and B ) duplicate themselves to form two different scenarios. By applying the SF solution, the new federates fedA[1] and B [1] participate in the original federation RT I [0], and there is no need for an additional federation to support the new scenario (labeled 1). By applying the MF solution, fedA[1] and B [1] form another federation RT I [1] to facilitate another scenario (labeled 1). The two kinds of solutions mentioned above involve different research issues and problems, especially at the RTI level. Table 1 gives a comparison showing the advantages and disadvantages of both solutions from different viewpoints. Making a trade-off among these issues is challenging work. As RTI does not provide destination- specic delivery in its object management services, it is mandatory that the single- federation solution requires an additional mechanism to isolate interactions among clones in different scenarios. 3.2 DDM versus Non-DDM in a Single-Federation Solution Separate scenarios can be isolated by using a straightforward approach that lters events at the receiver side. Each event is attached with the exclusive identity of the scenario of the sender. The receivers discard those events from other scenarios and merely reect those belonging to the same scenario. A minimal effort is required to enable this ltering in addition to the standard RTI services. It is possible to use DDM services to partition scenarios in the overall cloning-enabled distributed simulation. In general, the purpose of DDM services is to reduce the transmission and receipt of irrelevant data by the federates. Routing spaces are a collection of dimensions that represent coordinate axes of the federation problem space with a bounded range [9]. A region denes a multidimensional subspace in the routing space by dening the lower bound and upper bound on each dimension of the routing space. In DDM, data producers and consumers specify their data properties and data requirements by providing update regions and subscription regions. Data connection will be established between a pair of federates only when an update region and a subscription region overlap. With this property, DDM seems to be a natural candidate for de302 SIMULATION Volume 79, Number 56
veloping the mechanism to restrict the interaction among clones to within the same scenario. By assigning a scenario-specic region to one set of clones, the interactions will automatically be conned to this scenario. However, this incurs some extra overhead for managing the regions and increases the complexity of implementation. It is not necessary to introduce the DDM mechanism to the multiple-federation solution, as the communication trafc has already been conned within each federation. Thus, there are three candidate solutions for cloning HLA-based distributed simulations: the MF, the DDM single-federation solution (DSF), and the non-DDM single-federation solution (NDSF). These solutions can be evaluated by considering another important criterion their efciency. The trade-off between efciency and complexity is a main concern of the distributed system designer. Section 4 introduces the benchmark experiments to measure the overall performance of the three solutions in terms of execution time. 4. Benchmark Experiments and Results The primary objective of the experiments is to provide some criteria on complexity and efciency to help us decide what kind of cloning method we should adoptnamely, MF, DSF, and NDSF, as discussed. We will study the computation complexity involved using three factors: (1) the lower bound time stamp (LBTS) computation for time advance [4], (2) the interaction between federates, and (3) the load of the federate processes within a PC. The experiments explore how these factors affect the overall performance. The experiments will report results in execution time to perform a given task using each solution. 4.1 Experiment Design The experiments use three PCs in total (PCs 1, 2, and 3 in Figures 3 and 4), in which PC 2 executes the RTIEXEC and FEDEX processes [4]. The federates that run at one independent PC are enclosed in a dashed rectangle. In our case, fedA[i ] and fedB [i ] (i 1) occupy PC 1 and PC 3, respectively. The PCs are interlinked via an EtherFast 100 ve-port workgroup switch, which constructs an isolated subnet to avoid uctuation incurred by additional network trafc. The PCs conguration is as follows:
Intel 1700-MHz Pentium IV 256 Mbytes of RAM Windows 2000 Professional DMSO RTI NG 1.3 V4
The experiments emulate the simulation cloning process by increasing the number of identical federates. In Figures 3 and 4, fedA[1] and B [1] form a pair of initial federate partners, which represent the federates to be cloned. F edA[i ] and B [i ] (i > 1) stand for the i th clones of the two
Initial Scenario
57,>@

)HG $
)HG %
Reach Decision Point

)HG $ DFWLYH FORQLQJ )HG % SDVVLYH FORQLQJ
Single-federation Solution
Multiple-federation Solution
57,>@

57,>@

57,>@

)HG $>@
)HG $>@
)HG %>@
)HG %>@
)HG $>@
)HG $>@
)HG %>@
)HG %>@
Figure 2. An example of a single-federation solution and a multiple-federation solution
original federates, respectively. The federates are tailored based on the DMSO standard benchmarking programs (see http://sdc.dmso.mil). As indicated in Figure 3, each pair of fedA[i ] and B [i ] joins in an exclusive federation, which is denoted as RT I [i ]. We employ this set of scenarios to perform the benchmarking experiments for the MF solution. In Figure 4, all federates form one single federation; accordingly, we use this set of scenarios to measure the performance of NDSF and DSF solutions. Each federate is time constrained/time regulating or neither. In one run, each federate updates an attribute instance and receives an acknowledgment from its partner (from fedA[i ] to fedB [i ], and vice versa) for 10,000 times with a payload of 150 bytes. A federate merely reects the events with an identical ID to itself. In other words, fedA[i ] will discard any events not generated by fedB [i ], and vice versa. In time stamp order (TSO) mode, federates advance federate time from 0 to 10,000, with time step = 1 and lookahead
= 1. To investigate the efciency for time synchronization among federates, we also examine the execution time for the standard time advancement benchmarking federates using both the MF and SF solutions (see http://sdc.dmso.mil). Each federate can also be set as DDM enabled and non-DDM. An exclusive ID is shared between fedA[i ] and fedB [i ]. In the DDM-enabled mode, each pair of federates has an associated region, which is pair specic and nonoverlapping to any other region. The current DMSO RTI-NG [4] supports a number of DDM dataltering strategies, one of which is the StaticGridPartitioned strategy. This strategy partitions individual spaces into a grid in which each grid partition is assigned a separate reliable and best-effort channel [10]. To optimize the utilization of communication channels, we split the full dimension, [MIN_EXTENT, MAX_EXTENT), evenly into the same number of segments as NumPartitionsPerDimension (NPPD). The middle point of each segment will be dened as one region. We set the region associated to the
Chen et al.
3&
3&

3&

)(' $>@ )(' $>@ )(' $>@ )(' $>@ )(' $>@
57, 57, 57, 57, 57,
)(' %>@ )(' %>@ )(' %>@ )(' %>@ )(' %>@
Figure 3. Test bed for the multiple-federation solution (MF)
3&
3&

3&
)(' $>@ )(' $>@ )(' $>@ )(' $>@ )(' $>@
)(' %>@ >%@ )(' %>@ >%@ )(' %>@ >%@ )(' %>@ >%@ )(' %>@ >%@
57,
Figure 4. Test bed for the data distribution management single-federation solution (DSF) and the nondata distribution management single-federation solution (NDSF)
Table 1. Comparison between single-federation and multiple-federation solutions

Issues Interaction Synchronization Complexity of sharing Robustness Management of clones Single-Federation Additional mechanism is needed to deal with unnecessary event crossing among concurrent scenarios. Unnecessary synchronization among clones in different scenarios is inevitable. Clone sharing is available in a single federation. If a runtime infrastructure (RTI) instance crashes, the simulation will fail. Management of clones is easier inside the same federation. Multiple-Federation Interaction between clones in various scenarios is isolated by default. Synchronization among clones in different scenarios is eliminated. Clone sharing is difcult among federations. Multiple RTI instances for one user federation are maintained, and thus one RTI instance crash will not result in failure of the whole simulation. Management of clones crossing multiple federations is indirect.
k th pair of federates as follows: (2k 1)(MAX_EXTENT-MIN_EXTENT) 2 NPPD + MIN_EXTENT, (2k 1)(MAX_EXTENT-MIN_EXTENT) 2 NPPD + MIN_EXTENT + 1. In these experiments, all federates subscribe and publish the same object class and associate the designated region to their subscription and updates. 4.2 Benchmark Results and Analysis Some abbreviated notations are used to denote the properties of the federates, as listed in Table 2. To investigate the factors that affect the performance of alternative solutions, we designed several series of experiments, as indexed in Table 3. The notations are the same as in the previous discussion. Combining the time features and solutions together, we perform eight series of experiments in total. In each series of experiments, the number of federates increases by 1 pair each time, from 5 pairs to 14 pairs. 4.2.1 Comparing Alternative Cloning Solutions Using Timestamp Order (TSO) Federates Figure 5 reports the execution time of TSO federates using the three different solutions. The execution time of the TSO-NDSF scenarios has an obvious increase when the number of federate pairs reaches 7. When no DDM services are used, the execution time increases sharply with more and more TSO federates joining the same federation. The topmost value (2800 seconds, 14 pairs) is more than ve times the start value (500 seconds, 5 pairs). On the contrary, the execution times of both the TSO-DSF and TSO-MF scenarios stay at a relative stable level, about 500 seconds, despite the increase in the number of participating federates.
Execution Time (Seconds)
3000 2500 2000 1500 1000 500 0
Execution Time Comparison Between Different Cloning Solutions using TSO Federates
TSO-NDSF TSO-DSF TSO-MF
8 9 10 11 12 13 14 Federate Pairs
Figure 5. Execution time comparison among TSO federate cloning mechanisms. For denitions of notations, see Table 2.
In the single-federation mode, all federates interact with each other through the same RTI, and the computation load of LBTS increases with the number of federates. In the TSO-NDSF scenarios, of more importance is that each federate not only receives useful events from its partner federate but also has to lter out some useless messages from all other federates as they belong to other scenarios. The overall communication trafc through the RTI is proportional 1) 2 to Cn = n(n2 , where n is the number of federates. Only 1 of the total incoming events make sense to one partic(n1) ular federate pair. Other unnecessary communication and reection increase the overhead of communication in the RTI dramatically. The DDM services strictly conne the interaction to the pair of federates with a common region. This optimization results in the signicantly improved performance, as indicated in the curve TSO-DSF. In multiple-federation mode, a federate interacts with its partner through an exclusive RTI. Also the LBTS computations will take place between a pair of federates independently. These positive factors lead to the much better performance compared with the TSO-NDSF scenarios.
Chen et al.
Table 2. Notations of the federate attributes

Notations TSO RO SYN MF DSF NDSF Meaning Federates are time regulating/time constrained and use time stamp order update and reection Federates use receive order update and reection only Standard DMSO time advancement benchmarking application Experiment in multiple-federation (MF) mode Experiment in single-federation (SF) mode using data distribution management (DDM) Experiment in SF mode without using DDM
Table 3. The index of the experiments

TSO NDSF DSF MF Experiment 1: TSO-NDSF Experiment 2: TSO-DSF Experiment 3: TSO-MF RO Experiment 4: RO-NDSF Experiment 5: RO-DSF Experiment 6: RO-MF SYN Experiment 7: SYN-SF Experiment 8: SYN- MF
Note. For denitions of notations, see Table 2.
CPU Utilization Comparison Between Different Cloning Solutions using TSO Federates
4.2.2 Comparing Alternative Cloning Solutions Using Receive Order (RO) Federates To further investigate the computational complexity in these solutions, we disable the time feature of federates and reapply the three solutions to them. Execution time and CPU utilization are presented in Figure 7 and Figure 8. Similar to the previous experiments, the execution time of RO-NDSF scenarios increases rapidly with the number of federates. The peak execution time (1200 seconds, 14 pairs) is about six times the start value (200 seconds, 5 pairs). The execution time of RO-NDSF scenarios always has a greater value than that of RO-DSF and RO-MF scenarios. The RO-DSF and RO-MF scenarios have execution times that uctuate slightly from 100 seconds to 200 seconds. From the discussion of the TSO scenarios, the extra communication and reection lower the performance of RO-NDSF solutions signicantly. Figure 8 also shows that the RO-NDSF scenarios consume much more system resources than the other two solutions. The CPU utilization of the RO-NDSF scenarios jumps to 100% after the number of federate pairs exceeds 6. The RO-DSF and RO-MF scenarios have a very low CPU utilization (less than 10%) until there are more than 12 pairs of federates. 4.2.3 Comparing Alternative Cloning Solutions by Using the Time Advancement Benchmark To have a better understanding of how another factor, the LBTS calculation, affects the performance, we reexamine the SF and MF solutions by introducing the standard time advancement benchmark federates (see http://sdc.dmso.mil). Execution time and CPU utilization of both solutions are shown in Figure 9 and Figure 10. As DDM does not intervene in the synchronization among federates, this series of benchmarks ignores the DDM mechanism.
100 CPU Utilization (%) 80 60 40 20 0 5 6 7

TSO-NDSF TSO-DSF TSO-MF
8 9 10 11 12 13 14 Federate Pairs
Figure 6. CPU utilization comparison among TSO federate cloning mechanisms. For denitions of notations, see Table 2.
CPU utilization percentage reports the processor activity in the computer. This counter sums the average non-idle time of all processors during the sample interval and divides it by the number of processors. The CPU utilization results in Figure 6 indicate that the TSO-NDSF scenarios consume much more system resource than the other two solutions. However, the TSO-DSF and TSO-MF scenarios also have an uptrend in terms of CPU utilization. The CPU utilization of the TSO-NDSF scenarios reaches about 90% after the number of federate pairs exceeds 7. These experiments are a combination of complex executions, including LBTS and TSO events receiving and reecting. We attempt to isolate these two factors in the following experiments.
1400 1200 1000 800 600 400 200 0
Execution Time Comparison Between Different Cloning Solutions using RO federates

RO-NDSF RO-DSF RO-MF
503 502.5 502 501.5 501 500.5 500 499.5
Execution time Comparision between Alternative Solutions Using SYN federates

SYN-MF SYN-SF
8 9 10 11 12 13 14 Federate Pairs
8 9 10 11 12 13 14 Federate Pairs
Figure 7. Execution time comparison between cloning solutions using RO federates. For denitions of notations, see Table 2.
Figure 9. Execution time comparison between cloning solutions using time advancement federates. For denitions of notations, see Table 2.
100
CPU Utilization (%)
CPU Utilization Com parison Between Different Cloning Solutions using RO federates
100 80 60 40 20 0
CPU Utilization Comparision between Alternative Solutions Using SYN federates
CPU Utilization (%)
80 60 40 20 0
SYN-MF SYN-SF
RO -NDSF RO -DSF RO -MF
5
5 6 7 8 9 10 11 12 13 14 Federate Pairs
8 9 10 11 12 13 14 Federate Pairs
Figure 8. CPU utilization comparison between cloning solutions using RO federates. For denitions of notations, see Table 2.
Figure 10. CPU utilization comparison between cloning solutions using time advancement federates. For denitions of notations, see Table 2.
We can conclude that the LBTS calculation does not make a signicant difference in either the MF or SF scenarios with an increase in the number of federates. The RO-NDSF and TSO-NDSF scenarios show a fast increasing execution time. It means that the reduction of interactions is the key to the optimization of the overall system performance in the simulation as long as the number of federates stays in a reasonable range. 5. Managing Scenarios Experimental results have indicated that the performance of the DDM-based approach is encouraging compared with a non-DDM approach. We only consider the singlefederation solution in the following discussion as it is rel-
atively easier to manage clones and share computation among different scenarios. In this section, we focus on the issues related to the concurrent scenarios in the singlefederation architecture. We propose two DDM-based alternative solutions to manage the scenariosnamely, the recursive region division solution and the point region solution. We give the details of the two solutions and also compare their advantages and drawbacks. The issues include coding scenarios, region specication for each scenario, and ensuring user transparency through the middleware approach. 5.1 Scenario Tree In the context of distributed simulation cloning, each clone (federate) is an individual entity, whereas each scenario is
Chen et al.
Simulation Time
0
Fed A[0]
Fed B[0] Fed B[0] Fed B[1] Fed B[0] Fed B[1] Fed B[0] Fed B[1]
Event X
t X' Even
Fed C[0]
S[0]
B[0] performs active cloning
T1
Fed A[0]
Fed C[0]
X == X'
Event X
C[0] performs passive cloning
T2
Fed A[0]
Fed C[0] Fed C[1] Fed C[0] Fed C[1] Fed C[2]
S[1]
Event X'
X != X'
S[0]
C[1] performs active cloning
T3
Fed A[0]
S[2] S[1]
(A)
Figure 11. An example of incremental cloning and scenario tree
(B)
a dynamic group that involves a changing combination of member clones. Each scenario reports simulation results independently; it is the basic unit in our consideration and discussion. Only active cloning can drive the creation of new scenarios. We use a tree data structure to represent the relationship and development of the scenarios. Active cloning of any federate will incur the coordination of all other related clone federates. Figure 11 gives an example of a cloning-enabled simulation in which fedA[0] operates as an event publisher and fedB [0] and fedC [0] exchange events. Part (A) illustrates the details of the overall cloning procedure. Part (B) gives an abstraction of the scenario tree, in which each parent node (full dot) represents an occurrence of active cloning. The leaf nodes (circle) stand for active scenarios at the current simulation time. An active cloning results in the spawning of new scenarios, which is reected in the gure as parent nodes that have multiple children. Each scenario is marked as S [i ] (i = 0, 1, 2, . . .). The scenario tree grows along the simulation time axis as follows:
At simulation time 0, there exists a single scenario S [0]. When simulation time is advanced to T 1, fed B meets a decision point and performs active cloning, splitting into
clones B [0] and B [1]. A new branch S [1] is created in the scenario tree at this point. An event generated by B [0] is named as event X , while an event from B [1] is called event X . F edC [0] keeps intact, and this will continue as long as events X and X remain the same. F edC [0] operates as a shared clone for the duration between time T 1 and time T 2. At simulation time T 2, when an event X deviates from event X , this incurs a passive cloning of fed C and results in the birth of clone C [1]. This passive cloning does not trigger any change in the scenario tree. At simulation time T 3, FedC [1] performs an active cloning, spawning off clone C [2]. A new scenario is created and marked as S [2] in the scenario tree.
A combinatorial explosion of scenarios in clone-based distributed simulation may occur in some situations. The number of possible scenarios is determined by (1) the number of active cloning federates, (2) the times those federates perform active cloning, and (3) the candidate choices that each decision point represents. Human intervention may reduce the combinatorial explosion, but it is difcult to reach a general solution.
In practice, it is unlikely that such a combinatorial explosion will occur. For example, in a supply chain simulation, one company may wish to examine its own decision strategies concurrently. It is unlikely that one company could manipulate its partners internal decision policies. So in this case, there will be only one or a few federates that perform active cloning while the remaining federates perform passive cloning at the request of the active cloning federates. From the above discussion, we observe that different scenarios may have common member clones. The relationship between scenarios and clones can be complex and highly dynamic. There is a need for an identication and partitioning mechanism to manage the concurrent scenarios in the distributed simulation cloning procedure. This requires us to:
represent the relationship among scenarios, identify and control each scenario and clone, partition the event messages belonging to different scenarios, support the sharing of clones between scenarios, manage regions and map each scenario to its associated region, provide reusability to user federates while enabling the former functionalities.
6LPXODWLRQ 7LPH

7
7
Figure 12. An example of a scenario tree
The concurrent scenarios can be represented as a tree developing along the simulation time axis. To illustrate the details of the DDM solutions, the example in Figure 12 is referred to in studying the coding scheme in the following sections. Seven scenarios (labeled a to g) are present in the overall simulation following two active clonings at times T 1 and T 2, respectively. To minimize computation involved in the DDM, we use only one single routing space having a single dimension for cloning. To ease discussion, we assume the federates being studied do not use DDM services. However, federates that already use DDM services can also easily apply the solutions without changing the federate code. This can be achieved by associating another cloning dimension in the middleware to the existing DDM-enabled updates when necessary. The RTI offers a region modication method to enable the dynamic change of subspace without creating a different region. The change takes effect immediately after notifying the RTI. This feature enables the adjustment of a clones characteristic region at runtime; thus, dynamic routing and ltering of events from one clone to different scenario combinations can be realized. The underlying DDM module subscribes and publishes the same region for each clone. Each scenario is associated with an exclusive region, and there is no overlap with any other scenarios region. Clones within the same scenario use a common scenario-specic region extent1 unless they
1. In this article, extent is used to mean the interval [Lower_Bound, Upper_Bound) that denes the region.
are shared clones. A shared clone has a merged region that exactly covers the scenario-specic extents of all the scenarios in which it operates. DDM also aids interactive control of the scenarios at runtime; external commands can be easily routed to the clones within a given scenario by associating the proper region to them. The approach will lessen the work of recognition and processing at the clone side. Our potential solutions for managing scenarios aim to provide a standard interface of object management (OM) or DDM services while employing additional DDM methods in the underlying communication layer. Thus, it is possible to hide the DDM solution implementation behind the normal OM or DDM services interface in a transparent way. The solutions to be discussed focus on addressing the manipulation of regions and the mapping between each region and the scenarios. 5.2 Recursive Region Division Solution The basic idea of the recursive region division solution is to divide the full dimension (i.e., [MIN_EXTENT, MAX_EXTENT)) from top to bottom. A federation is initialized with all federates having an associated region with extent [MIN_EXTENT, MAX_EXTENT); thereby, the initial scenario has a full-dimension region. Once new scenarios are created, each scenario inherits a subregion from its parent scenario under a region division algorithm. Thus, the active cloning federate should divide its original region for the child clones, while its partner may still keep the region unchanged. In the example shown in Figure 11, immediately after time T 1, fedB [0]s original region is split into two parts; fedB [0] and fedB [1] modify
Chen et al.
Example: n = 5 = 2^2 + 1 k =2+1=3 , m = 1 new levels = 3 leftmost node at this level
predecessor scenario
Figure 13. Development of binary scenario tree
their region with the rst and the second part, respectively. The new regions indicate that fedB [0] and fedB [1] belong to scenario S [0] and S [1], respectively, but fedC [0] will remain associated with the region of both scenarios S [0] and S [1]. Thus, the events from both fedB [0] and fedB [1] will be automatically routed to fedC [0] without any modication to its region. This solution requires minimal work for shared clones. Region division keeps taking place along the development of the scenario tree. The scenario tree can be reconstructed as a binary tree to ease coding. When n new scenarios are developed from one scenario branch, the following rule will be applied: given that 2k1 < n 2k , n is rewritten as n = 2k1 + m, m 2k1 . Then the branch extends k levels downwards, and the leftmost m nodes at level k 1 will always be expanded as parent nodes. Following this rule, the scenario tree in Figure 12 is converted to a binary tree. Suppose that ve new scenarios are created from the predecessor scenario node; the development of this branch is as indicated in Figure 13. The leaf nodes represent the newborn scenarios, including the original one. As shown in Figure 14A, we code a nodes left branch as 0 and the right branch as 1 accordingly. Based on the binary tree, we link the branch codes together along the path from the root to the given leaf node, and thus the exclusive code of each scenario is achieved. For example, scenario e is identied as 0011. The position of the scenario can be easily traced according to its identity. A shared clone needs to distinguish events from different clones that are spawned by the same federate. We may also need to control the cloning procedure or update the system state of one particular clone. Therefore, it is necessary to identify each clone accurately. A clone always joins one or multiple scenarios; naturally, the clone identity needs to cover this information. A direct scheme is to combine scenario codes and the federate name of the ancestor to this clone, with format <Scenario ID>&&<Federate Name>. For example, when a clone joins scenario e and
its ancestor federate is named as fab1, this clone may be coded as 0011&&fab1. In the case of shared clones, a delimiter symbol is placed between scenarios; if necessary, a wildcard is also introduced to reduce the identity length. The format is <Scenario ID 1>:<Scenario ID 2>: ... : <Scenario ID N>&&<Federate Name>, in which : is a delimiter and * is the wildcard. For example, if another clone of ancestor fab2 is shared among scenario a , b, and g , this clone is coded as 0000*:1&&fab2. Figure 14B gives the region-coding scheme. The relationship between the position of a scenario node and its specic region is illustrated explicitly. The full dimension is segmented more and more densely with the increase in level depth. At the k th level (mapping the nodes in the binary tree with depth equal to k ), the full dimension is evenly partitioned into n = 2k segments. Each segment is given a binary code according to its index, with the code length equal to the level depth. The segment code is length sensitive (e.g., the code 011 at level 3 differs from the code 0011 at level 4). For the purpose of illustration, assume that MIN_EXTENT = 0x00000000 and MAX_EXTENT = 0xFFFFFFFF; the following simple formula gives the calculation of the extent of the i th segment at level k : Lower Bound = i 232k , Upper Bound = (i + 1) 232k 1. (1)
The code of each scenario coincides with the segment code perfectly. The extent of the scenario-specic region can be directly obtained from the scenario code. First, we assign the length of scenario code to k ; second, we calculate i = atol(scenario code), and then the extent of the region is available immediately from equation (1). For example, the code of scenario e is 0011, and then we have k = strlen(0011)= 4 and i = atol(0011)= 3: Lower Bound = 3 2324 , Upper Bound = (3 + 1) 2324 1. The region extent of scenario e is [0x30000000, 0x3FFFFFFF). The one-to-one map between a scenario code and the region extent is constant for any simulation. This feature implies that we do not have to record the map between a scenario ID and its specic region extent. Using the recursive region division solution avoids the need for a searching procedure. The full dimension [MIN_EXTENT, MAX_EXTENT) contains 232 unique extents at most. Thereby, 232 concurrent scenarios are allowed when making full use of the dimension. Such a large number is able to meet any practical requirement for classifying scenarios. However, the binary division algorithm may incur problems in some extreme situations. Let us look at a special example, in which, on active cloning, only the leftmost branch in the binary scenario tree splits into multiple new scenarios. Thus, the
GHSWK RI WUHH

0,1B(;7(17
[
18//
0$;B(;7(17
[))))))))
J I

F E
H
D
00000
H
0011
I
01
J
1
00001 0001 0010
(A) Coding the Binary Scenario tree
(B) Coding the Region extent and specifying region for each scenario
Figure 14. Binary scenario tree and scenario region code
region extent of the leftmost scenario will shrink rapidly in an exponential way, much faster than other scenarios. It can be seen that region allocation is densely concentrated at the left end of the dimension, whereas only a few scenarios occupy the remainder of dimension. As this continues, when the depth of the binary tree reaches 32, one scenarios region extent becomes a point, and child scenarios are not able to inherit extents any more. This potential limitation exists even if this is unlikely to occur. Once the extent is exhausted in the single-clone dimension, one possible solution is to redistribute the extents of the full dimension. Undoubtedly, the redistribution incurs extra complexity, and it damages the natural harmony of the one-to-one map between scenario identity and its region extent. Alternatively, we can specify a multiple-dimensional routing space for cloning beforehand. A clone region is created with these dimensions, and the recursive division algorithm is initially applied to the rst dimension. When the extent is exhausted in this dimension, the subsequent dimensions are still available for extent allocation using the same recursive division algorithm. This approach is able to keep the coding scheme intact. As long as the number of clone dimensions is set large enough, it should meet any request in practice. 5.3 Point Region Solution An alternative solution, namely, the point region solution, is proposed to distribute the extents of the dimension as evenly as possible in a bottom-to-top manner. A point region has an extent dened as [Lower_Bound, Lower_Bound+1). As the name implies, the point region is the element in associating a region with a scenario. The
initial federates are assigned a start point region. Instead of inheriting any region from their predecessor, the new scenarios get different point regions from the dimension. A shared clone has to combine its original region with the new ones associated with additional scenarios. Thus, scenarios can be coded based on the scenario tree. Figure 15 illustrates a coded scenario tree. In this solution, on an active cloning, no matter how many new scenarios are created from a scenario, the scenario extends only one level down with all new scenarios and itself. From left to right, sibling branches of any scenario are labeled from 0 to n. For the scenarios that remain unsplit, in the scenario tree, the corresponding nodes still extend one level down with one single child to keep consistency in representing current scenarios and the cloning history along the simulation time axis. By simply linking codes starting from the root, the identity of a scenario is obtained. To ease representing and resolving the scenario identity, we can record the label of each branch in a hexadecimal format, whereby each byte holds a siblings code, and thus scenario es identity is written as 0004. The clone identity follows the format dened in the previous recursive division solution. Given the same examples in section 5.2, we can code the descendant clone of original federate fab1 as 0004&&fab1. As for another clone with ancestor fab2, which is shared by scenarios a , b, and g , we may code it as 0000:0001:0200&&fab2. This shared clone has a region that is a union of region extents associated with scenarios a , b, and g . To optimize the usage of communication channels provided by DDM in RTI-NG, we divide the single cloning dimension into multiple segments evenly according to
Chen et al.
6LPXODWLRQ 7LPH
1 8 / / 7

R0,0 R1,0 : R( NPPD 1),0
R0,1 ... ... ...
R0,( 232 / NPPD 1) : : R( NPPD 1),( 232 / NPPD 1)
7

Figure 16. Point region allocation ow

Figure 15. Coding the scenario tree
the NumPartitionsPerDimension(NPPD) in the RTI.rid le [10]. Each segment will contain an identical number of point regions. To ease discussion, here we still assume that that MIN_EXTENT = 0x00000000 and MAX_EXTENT = 0xFFFFFFFF. The following matrix describes the distribution of all available point regions with the number of rows equal to NPPDand the number of columns equal to ([USE [ ?]MAX_EXTENT- MIN_EXTENT+1)/NPPD. It is obvious that the points in one row belong to same segment in the dimension. R0,1 R0,(232 /NPPD1) R0,0 : R1,0 Rgn = , : : R(NPPD1),0 R(NPPD1),(232 /NPPD1) where Ri,j = (232 /NPPD) i + j (2) In total, there can be up to 232 available point regions in which the j th point region in the i th row is written as [Ri,j , Ri,j + 1). The initial scenario starts with a region [R0,0 , R0,0 + 1). A new scenario will always be assigned the rst unused point region in the next row. Once the regions in same column are fully used, the allocation will start from the beginning of the next column. Figure 16 illustrates this region, specifying ow as indicated by the arrowed line. The scenario ID maps to its specied region in a one-to-one way. The scenario tree records the scenario ID and the region in the node for that scenario and can be used for resolving the region of one particular scenario from its identity by searching the tree. The scenario ID is resolved to locate the scenario node in the tree, and this
search is performed along a given path instead of making a full search of the scenario tree. The mapping relationship in the point region solution may vary in different simulation runs. The point region solution has an added advantage in that it maximizes the use of available communication channels. For each routing space, RTI-NG will create NPPDNumber of Dimensions reliable and best-effort channels. The channels are mapped to the dimension in a grid-like fashion. As we only dene one dimension, RTI provides exactly NPPDchannels for the cloning space in our solution. The point regions in the same row (see the matrix in equation (2)) occupy a common data channel. The point region ensures that the update data it is associated with use a unique data channel and avoids the overhead of sending data through multiple channels unnecessarily. However, this solution does not support a direct conversion between the scenario ID and region; the scenario manager module needs to record this mapping. Furthermore, shared clones need to modify their regions on the latest active cloning. This incurs extra effort compared with the recursive region division solution. 5.4 DDM in RTI++ No matter what kind of solution is chosen to perform simulation cloning, a critical principle is the reusability of the users program. Our solutions should minimize the modication to the users existing code, even though it is difcult to eliminate all extra complexity when enabling simulation cloning. We propose the middleware approach to hide the complexity, as indicated in Figure 17. We extend the standard RTI to RTI++ to encapsulate cloning operations directly related to the RTI while presenting the standard RTI interface to the user. The user code still uses the standard RTI interface, while the enhanced functionality remains transparent to the user. The middleware sits between the users code and the real RTI and contains a library for cloning management and the RTI++.
User's Program Middleware
RTI++
Standard RTI Interface Module Library DDM Interactive Control
Real RTI
Figure 17. Middleware for cloning. RTI = runtime infrastructure.
As mentioned previously, either of the solutions discussed should work as an underlying control mechanism with transparency to federate codes. Hiding the implementation details while enabling the management of scenarios can maximize the reusability of the users existing simulation model. Middleware exists between the RTI and federates and includes an implementation of the solutions addressed above. RTI++ software is built up to encapsulate the cloning-related modules while maintaining the same RTI interface to the calling federate code. Scenario manager and region manager modules are developed to implement the DDM solutions. Figure 18 gives the relationship between the cloning modules. The scenario manager module creates and stores the scenario tree, from which the identity and corresponding region of each scenario can be fetched. The scenario manager keeps the history of the overall cloning procedure. The cloning management module initiates the creation and update of the scenarios. The region manager module creates regions and manages the regions based on the aforementioned algorithm. The region manager will deal with any request for an updating region. The RTI++ object management services invoked by a federate are eventually executed via the corresponding DDM methods by associating the region obtained from the scenario manager. Figure 19 gives an example of pseudo-codes for implementing the above inside the middleware. 6. Conclusions and Future Work In this article, we have investigated some research issues in cloning HLA-based distributed simulations. A federate can perform cloning actively or passively according to its own or its partners requirements at the decision point. To make the most use of computation sharing, we have employed an incremental cloning mechanism in the design of our solutions to clone simulations. A middleware approach has
been used to hide the complexity incurred by simulation cloning and maximize the reusability of users simulation applications. Alternative candidate solutions have been compared in terms of efciency, complexity, and robustness. The singlefederation solution indicates an advantage in cloning control and cloning sharing. However, the multiple-federation solution surpasses in robustness and federate synchronization. The benchmark results indicate that, in general, MF exhibits much better performance than NDSF. The interaction among federates is the main factor that affects the execution speed. In the case when there is a high data exchange, the performance can be improved dramatically by applying DDM to NDSF. The calculation of LBTS makes no signicant difference in both MF and SF solutions. The results show that DSF performs as well as MF in terms of efciency. Considering the reduction of implementation complexity and convenience for scenario management, we chose the single-federation solution applying DDM for cloning distributed simulations in the current study. In this article, we have also studied issues involved in managing concurrent scenarios generated by distributed simulation cloning. Interactions need to be conned within each scenario to guarantee the correctness of simulation results. We also need to share computation for shared clones crossing multiple scenarios. DDM services are used in an underlying module to route events and partition scenarios. We analyzed the internal mechanism of RTI-NG DDM services to improve the DDM performance. A middleware approach covers the scenario management details and maximizes the reusability of user federate codes. Furthermore, to address the complexity of the overall cloning-enabled distributed simulation due to increasing scenario spawning, we investigated an efcient and precise scheme to identify and represent scenarios. Alternative candidate solutions have been proposed to code scenarios as well as to manipulate region extents in the cloning dimension. These are a recursive region division solution and a point region solution. The recursive region division solution has advantages because (1) it minimizes the extra overhead for shared clones, and (2) it provides a natural one-to- one mapping between scenario identity and region extent. The coding mechanism harmonizes with the region specication perfectly. However, the recursive region division solution has a limitation in dealing with some extreme situations. The point region solution has advantages over the former solution in that (1) it can meet the region allocation requirements even in extreme situations, and (2) it optimizes the use of data channels. For our future work, we need to explore the mechanism of the cloning operation and guarantee the correctness of new clones. One major concern is the design and implementation of system state saving and recovery at both the simulation level and the RTI level. Another major concern is the interactive manipulation of cloning-enabled simulation in a distributed environment, where users are offered the exibility to control and update the cloning online. How
Volume 79, Number 56 SIMULATION
313
Chen et al.
Figure 18. RTI++ and internal modules. RTI = runtime infrastructure; DDM = data distribution management.
Get region associated with current clone federate

currentRegion = scenManger ->getCloneRegion();
Override standard RTI functions with DDM enabled services

For example: RTIambassadorPlus::subscribeObjectClassAttributes (theClass, attributeList,...){
...
}
(RTI::RTIambassador*this)->subscribeObjectClassAttributesWithRegion(theClass, currentRegion, attributeList,...);
...
...
Figure 19. Example for RTI++ implementation. RTI = runtime infrastructure; DDM = data distribution management.
to achieve fault tolerance using the cloning mechanism is also a very important issue. 7. References
[1] Gan, Boon Ping, Li Liu, Sanjay Jain, Stephen John Turner, Wentong Cai, and Wen-Jing Hsu. 2000. Distributed supply chain simulation across enterprise boundaries. In Proceedings of the 2000 Winter
Simulation Conference, December, Orlando, FL, pp. 1245-51. [2] Turner, Stephen John, Wentong Cai, and Boon Ping Gan. 2001. Adapting a supply-chain simulation for HLA. In Proceedings of the Fourth IEEE International Workshop on Distributed Simulation and Real-Time Applications, August, San Francisco, pp. 67-74. [3] Dahmann, Judith S., Frederick Kuhl, and Richard Weatherly. 1998. Standards for simulation: As simple as possible but not simpler: The High Level Architecture for simulation. SIMULATION 71 (6): 378-87.
[4] DMSO/DOD, DMSO, Alexandria, VA, USA, Feb. 2002. RTI 1.3 Next generation programmers guide version 5. [5] Chen, Dan, Boon Ping Gan, Stephen John Turner, Wentong Cai, Nirupam Julka, and Junhu Wei. 2003. Evaluating alternative solutions for cloning in distributed simulation. In Proceedings of the 36th Annual Simulation Symposium, March, Orlando, FL, pp. 201-8. [6] Chen, Dan, Boon Ping Gan, Stephen John Turner, Wentong Cai, and Junhu Wei. 2003. Data distribution management in distributed simulation cloning. In Proceedings of 2003 European Simulation Interoperability Workshop, paper no. 03E-SIW-024, June, Stockholm, Sweden. [7] Hybinette, Maria, and Richard M. Fujimoto. 2001. Cloning parallel simulations. ACM Transactions on Modeling and Computer Simulation (TOMACS) 11:378-407. [8] Schulze, T., Steffen Straburger, and Ulrich Klein. 2000. HLA- federate reproduction procedures in public transportation federations. In Proceedings of the 2000 Summer Computer Simulation Conference, July, Vancouver, Canada. [9] Morse, K. L., and M. D. Petty. 2001. Data distribution management migration from DoD 1.3 to IEEE 1516. In Proceedings of the Fifth IEEE International Workshop on Distributed Simulation and Real-Time Applications, August, Cincinnati, OH, pp. 58-65. [10] Hyett, Mark, and Roger Wuerfel. 2002. Implementation of the data distribution management services in the RTI-NG. In Proceedings of 2002 Spring Simulation Interoperability Workshop, paper no. 02S-SIW-044, March, Orlando FL.
current research interests include parallel and distributed simulation, distributed virtual environments, grid computing, and multiagent systems. Boon Ping Gan is a research engineer with the Production and Logistics Planning Group at the Singapore Institute of Manufacturing Technology in Singapore. He received a bachelor of applied science degree in computer engineering and a master of applied science degree from the Nanyang Technological University of Singapore in 1995 and 1998, respectively. His research interests are parallel and distributed simulation, parallel programs scheduling, and application of genetic algorithms. Wentong Cai is currently an associate professor at the School of Computer Engineering (SCE), Nanyang Technological University (Singapore). He received his B.Sc. in computer science from Nankai University (Peoples Republic of China) and Ph.D., also in computer science, from the University of Exeter (United Kingdom). He was a postdoctoral research fellow at Queens University (Canada) from February 1991 to January 1993 and joined SCE as a lecturer in February 1993. He has served as program committee members in many international conferences (e.g., PADS, DSRT, and PDCS). He is a member of IEEE, and his current research interests are mainly in the areas of parallel and distributed computing (particularly, parallel & distributed simulation and grid computing). Junhu Wei is working with Nanyang Technological University (Singapore) as a research fellow sponsored by SIMTech under the research manpower program. He received his B.E. in automatic control, M.E. in system engineering, and Ph.D. in control engineering from Xian Jiaotong University (China). His current research interests include parallel and distributed simulation, simulation, planning, and scheduling of manufacturing. Nirupam Julka is an associate research engineer with the Production and Logistics Planning Group at the Singapore Institute of Manufacturing Technology in Singapore. He received a bachelor of technology (honors) degree from the Indian Institute of Technology (IIT), Kharagpur in 1999 and a master of engineering degree from the National University of Singapore in 2002. His research interests are parallel and distributed simulation, supply chain optimization, and management and decision support systems.
Dan Chen is a research engineer with the Productions and Logistics Planning Group at Singapore Institute of Manufacturing Technology in Singapore. He received a bachelor of science degree in applied physics from Wuhan University, China in 1994; a master of engineering degree in computer science from Huazhong University of Science and Technology, China in 1999; and a master of engineering degree in computer engineering from Nanyang Technological University, Singapore in 2002. His research interests are distributed simulation, networking, and other relative technologies. Stephen John Turner joined Nanyang Technological University (Singapore) in 1999 and is currently an associate professor in the School of Computer Engineering and director of the Parallel and Distributed Computing Center. Previously, he was a senior lecturer in computer science at Exeter University (UK). He received his M.A. in mathematics and computer science from Cambridge University (United Kingdom) and his M.Sc. and Ph.D. in computer science from Manchester University (United Kingdom). His
Volume 79, Number 56 SIMULATION
315

Alternative Solutions To Sim Cloning

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Alternative Solutions To Sim Cloning

Hochgeladen von

Copyright:

Verfügbare Formate

SIMULATION

http://sim.sagepub.com Alternative Solutions for Distributed Simulation Cloning

Society for Modeling and Simulation International (SCS)

Alternative Solutions for Distributed Simulation Cloning

300 SIMULATION Volume 79, Number 56

ALTERNATIVE SOLUTIONS FOR DISTRIBUTED SIMULATION CLONING

Queue Length > alert level ?

IDLE Batch Machine BUSY

Multiple dispatch rules

ALTERNATIVE SOLUTIONS FOR DISTRIBUTED SIMULATION CLONING

Reach Decision Point

Figure 2. An example of a single-federation solution and a multiple-federation solution

57,  57,  57,  57,  57, 

Figure 3. Test bed for the multiple-federation solution (MF)

304 SIMULATION Volume 79, Number 56

ALTERNATIVE SOLUTIONS FOR DISTRIBUTED SIMULATION CLONING

Table 1. Comparison between single-federation and multiple-federation solutions

3000 2500 2000 1500 1000 500 0

TSO-NDSF TSO-DSF TSO-MF

Table 2. Notations of the federate attributes

Table 3. The index of the experiments

Note. For denitions of notations, see Table 2.

100 CPU Utilization (%) 80 60 40 20 0 5 6 7

ALTERNATIVE SOLUTIONS FOR DISTRIBUTED SIMULATION CLONING

1400 1200 1000 800 600 400 200 0

Execution Time Comparison Between Different Cloning Solutions using RO federates

503 502.5 502 501.5 501 500.5 500 499.5

Execution time Comparision between Alternative Solutions Using SYN federates

Execution Time (Seconds)

Execution Time (Seconds)

CPU Utilization (%)

CPU Utilization Comparision between Alternative Solutions Using SYN federates

CPU Utilization (%)

RO -NDSF RO -DSF RO -MF

B[0] performs active cloning

C[0] performs passive cloning

C[1] performs active cloning

ALTERNATIVE SOLUTIONS FOR DISTRIBUTED SIMULATION CLONING

Figure 12. An example of a scenario tree

Example: n = 5 = 2^2 + 1 k =2+1=3 , m = 1 new levels = 3 leftmost node at this level

Figure 13. Development of binary scenario tree

ALTERNATIVE SOLUTIONS FOR DISTRIBUTED SIMULATION CLONING

[           

18//        

      

  

00001 0001 0010

(A) Coding the Binary Scenario tree

Figure 14. Binary scenario tree and scenario region code

R0,0 R1,0 : R( NPPD 1),0

R0,1 ... ... ...

R0,( 232 / NPPD 1) : : R( NPPD 1),( 232 / NPPD 1)

Figure 16. Point region allocation ow

      

ALTERNATIVE SOLUTIONS FOR DISTRIBUTED SIMULATION CLONING

User's Program Middleware

Figure 17. Middleware for cloning. RTI = runtime infrastructure.

Volume 79, Number 56 SIMULATION

Get region associated with current clone federate

Override standard RTI functions with DDM enabled services

(RTI::RTIambassador*this)->subscribeObjectClassAttributesWithRegion(theClass, currentRegion, attributeList,...);

314 SIMULATION Volume 79, Number 56

ALTERNATIVE SOLUTIONS FOR DISTRIBUTED SIMULATION CLONING

57, 57, 57, 57, 57,

[

18//