An Optimized Time-synchronization Method for Simulator Interworking

Abstract

In this paper, we discuss an optimization approach for time-synchronizations in networked simulators. This method is a sub-technology that is required to combine heterogeneous simulators into a single simulation. In previous time-synchronization studies, they had built a network system among networked simulators. The network system collects network packets and adds time-stamps to the networked packets based on the time that occurs in events of simulation objects in the individual simulators. Then, it sorts them in chronological order. Finally, the network system applies time-synchronization to each simulator participating in interworking sequentially. However, the previous approaches have a limitation in that other participating simulators should wait for while processing an event in a simulator in a time stamp order. In this paper, we attempt to solve the problem by optimizing time-synchronizations in networked simulation environments. In order to prove the practicality of our approach, we have conducted an experiment. Finally, we discuss the contributions of this paper.

1. INTRODUCTION

Time-synchronization means that two or more independent objects share a reference time. There are two ways to perform the time-synchronization using hardware and software. In most cases, the time-synchronization is implemented to maintain data consistency among the independent objects. Optimization refers to performing tasks with more effective time and fewer resources such as computing power. It mainly provides a theoretical solution to interprets mathematical problems more quickly or it minimizes the energy consumption of the system and realizes the same work performance. In this paper, we will discuss these two issues.

issues. In previous simulator interworking studies, there is a problem in that when one event handler processes an event in time-stamp order in another simulator, the other participant simulators must wait for the time. Therefore, in the simulator interworking environments, the waiting time for time synchronization increases as the number of the participant simulators increase. In this paper, we attempt to solve the problem by optimizing time-synchronizations in networked simulation environments. In networked systems, time-synchronizations are achieved through network protocols. There are two approaches to provide time-synchronizations. First, it is implementing a clock synchronization model, such as asynchronous and synchronous models, in middle of network systems. Second is keeping time synchronized by a satellite. This approach provides high precision time synchronization functions for embedded systems. With these existing approaches, we have difficulties to synchronize one virtual time in the simulation among simulators.

present a new method for time-synchronizations in networked simulators1). The method is composed of two phases: the preliminary processing and post-processing. Tasks in these phases are performed in accordance to the synchronization time unit. Each simulator converts states of a simulation object within a simulation progress time by referencing one integrated packet set of events synchronized with the synchronization time unit. Therefore, we can eliminate waiting time between simulators and provide optimized time-synchronization for simulator interworking. The preliminary processing and post-processing can also be performed in parallel to minimize the overall simulation computation time. In this paper, we will conduct a case study and provide the results of overall experiments. However, we do not discuss the detailed data in the case study because of confidentiality reasons.

The remainder of this paper is organized as follows: Section 2 discusses background knowledge of time-synchronizations; Section 3 presents our time-synchronizations method; In Section 4, we introduce a small experiment; As the conclusion, Section 5 summarizes the contributions and our future works.

2. Related Works

According to Mahmood et. al.[1], there are two typical protocols of clock synchronization: NTP (Network Time Protocol) and PTP(Precision Time Protocol). NTP is mainly used in distributed systems due to limitations of accuracy and precision. PTP can use hardware time-stamps to ensure high accuracy of clock synchronization. However, it has a drawback that it cannot be implemented in all hardware or software systems. For instance, Android operating system does not support PTP. NTP is widely used for systems to synchronize clock over networks. NTP uses International Standard Clock(such as UTC and GPS) and is applied to a distributed network that constructed with a distributed hierarchical structure. It synchronizes time among nodes using packet information to be exchanged with considerations of their delay and offset,

There are two approaches to implement clock synchronization. First is establishing a software system in a middle of network nodes, which uses deterministic algorithms, in order to distribute synchronized time to the network nodes. Second, it is keeping time synchronized by a satellite; in other words, each network node has a receiver to obtain time signals from the satellite repeatedly. According to Simons et.al.[2], there are four clock synchronization models in the first approach; such as asynchronous reliable model[5, 15, 16], asynchronous unreliable model[3, 4, 7, 12], partially synchronous reliable model[10, 13, 14], and partially synchronous unreliable model[6]. The asynchronous reliable model indicates that packet delays are not controlled; however, it maintains a discrete clock to keep consistent of communications. There are six types of packet delays such as send time, access time, transmission time, propagation time, reception time, and receive time delays[20]. The send time delay is spent time of assembling a packet and delivering it to a MAC layer in sender. The access time delay indicates waiting time for accessing communication channel. The transmission time delay indicates taking time on transmitting bit by bit in a physical layer. The propagation time delay means spent time to travel a bit from sender to receiver. The reception time delay is taking time to receiving a packet from communication channel. At last, the receive time delay indicates incoming and delivery time of the packet to an application layer.

o an application layer. The asynchronous unreliable model means both connections and packet delays are not considered for loose couplings of network nodes. In the partially synchronous reliable model, each network node keeps real-time clocks as repeatedly receiving the same rate of packets. In additional, it should maintain and calibrate packet delays in pre-defined upper and lower bounds. Finally, the partially synchronous unreliable model indicates that packet delays are not guaranteed; however, broadcasted packets are adjusted to keep the real-time clocks such as skipping jobs on network nodes.

IEEE 1588[8] is developed for implementing high precision time synchronization functions of embedded systems. It is the Sender-Receiver synchronization method and the time providing node is called master-node, and the partner node is called slave-node. RBS stands for Reference Broadcast Synchronization, and it takes Receiver-Receiver synchronization scheme. In other words, a beacon node serving as a reference of time synchronization broadcasts and synchronizes a synchronization signal to neighboring nodes[18]. As an application of RBS, sending a packet that does not contain a time-stamp; on the receiving side, time was synchronized considering and comparing only arrival time of packets was studied[9]. Therefore, heavy computations of NTPs was relieved. The Flooding Time Synchronization Protocol was proposed in order to synchronize large quantities of equipment that have limited resources such as wireless sensor networks[17]. Thus, all of the existing studies consider only the current time synchronization between network nodes. Moreover, these studies show the time synchronization accuracy between distributed systems or sensor networks, and focus on low energy consumptions when performing time synchronization[20]. It is difficult to synchronize one virtual time in the simulation among simulators with these existing studies. The purpose of the time-synchronization of our paper is to optimize the computation time consumed by each simulator through optimized synchronization of simulation time.

3. AN OPTIMIZED TIME-SYNCHRONIZATION METHOD

In our approach, several simulators can be physically connected through a network hub or WIFE modules. It does not limit the number of connections. However, a simulator interworking system should be on the network. Under these environments, they can only exchange network packets thought our time synchronization software module. Fig. 1 illustrates the configuration in our approaches.

Fig. 1. The Network configuration for simulator interworking.

Simulator interworking requires to share simulation time for several simulators, and the shared simulation time also is limited to each simulator. During the simulation time, each simulator processes events among its simulation objects as an independent simulation. First, there is a simulation time and time interval in the given simulation time. The simulator interworking is time-synchronized on a per-time basis. The time interval can be arbitrarily determined such as 0.1 or 0.01 second. The smaller the time interval, the greater the accuracy of the simulation is provided. However, as the number of synchronization times of the time-synchronization module increases, the overall simulation execution time increases. Fig. 2 is schematized to show concepts of the time-synchronization module.

Fig. 2. A conceptual diagram for time-synchronization module algorithm.

The time-synchronization module is composed of preliminary processing phase and post-processing phase. The Fig. 3 shows an abstract flowchart of the execution algorithm of our time synchronization module.

Fig. 3. The abstract flowchart of the execution algorithm.

In preliminary processing phase, packets received from each simulator arranges in the same progress time(i.e. in the same time-stamp). The packets with the same progress time aggregate into one set of packets and deliver them to all simulators at once. These tasks are performed in synchronization unit time. In post-processing phase, status of simulation objects in each simulator are changed based on the set of packets from preliminary processing phase and the synchronization unit time. The time-synchronization module conduct a series of these phases in parallel. The Fig. 4 is schematized to illustrate our algorithm of preliminary processing phase in the time-synchronization module.

Fig. 4. The algorithm of preliminary processing phase in the time-synchronization module.

First, we input the simulation total time. Second, it is determined whether the current progress time(t_present) exceeds the entire simulation time. If the current progress time(t_present) exceeds the entire simulation time, we end the algorithm in preliminary processing phase. Otherwise, we collect packets in the current progress time(t_present). Then, we consolidate collected packets into one packet set. We suppose that each simulator has same cycle of simulation time such as 0.1 or 0.01 second. In cases of that there is differences between participating simulators, the simulator with the fastest simulation time cycle is synchronized to slow simulation time cycle of the other simulator[11] when a packet integration is generated. Fig. 5 is a conceptual diagram for explaining a packet integration into one set.

Fig. 5. A conceptual diagram for a packet integration into one set.

If there is no event in the integrated packet set, we discard the packet set. Otherwise, we progress next step. Third, we check that the current progress time(t_present) has exceeded the synchronization time unit(t_synchro_time_unit). In a case of exceeding the unit time, we progress next simulation time interval(t_interval). In the other case, we enter new synchronization unit time and progress next simulation time interval(t_interval) in the new synchronization unit time. Finally, we broadcast the packet set in the previous synchronization unit time when it is entering the new synchronization unit time. Fig. 6 illustrates the algorithm flowchart of our post-processing phase.

Fig. 6. The algorithm flowchart of the post-processing phase.

In the post-processing phase, time-synchronization modules in each simulator performs individually. First, the time-synchronization module receives a packet set broadcasted from preliminary processing phase. Then, it progresses time interval(t_interval) in synchronization time unit. Second, it checks whether there is an event or not in the time interval. In cases of event occurrence, we apply the event to the simulation objects and change the state of them. If there is no event occurrence, it directly takes next step. Third, we check that the progresses of the time interval(t_interval) is completed in synchronization time unit. If there is time interval(t_interval) to progress, we go back to the first step. Otherwise, we check again whether the current progress time(t_present) exceeds the total simulation time. In cases of exceeding the total simulation time, the time synchronization algorithm is ended. Otherwise, the time-synchronization module waits for another packet set broadcasted from preliminary processing phase. In other words, in post-processing phase of the time-synchronization, it performs a waiting activity until there is a broadcasting activity of the next integrated packet sets.

4. AN EVALUATION

In this section, we conduct a case study for theoretically evaluation of our approach. As the simulation space, the Korean Peninsula had been set. In the simulation space, we have established three engagements; namely, Surface-to-Surface Missile (STSM) simulation, Air-to-Surface(ATSM) missile simulation, and fixed/mobile target simulations. First, the STSM targets the fixed target. In the STSM, the location of the launcher is 37.57(deg.) in latitude and 126.98(deg.) in longitude. Its impact location is 33.75(deg.) in latitude and 126.58(deg.) in longitude. Therefore, the flight distance of the STSM is 465.78 kilometers. The location of the fixed target is 33.38(deg.) in latitude and 126.55 (deg.) in longitude. Therefore, mis-distance of the STSM is 40499.83 meters. As a result of the simulation, the mission of the STSM is failed since the damage radius of its warhead is 100.0 meters.

Second, the ATSM targets the mobile target. In the ATSM, the location of the launcher is 36.57 (deg.) in latitude and 125.98(deg.) in longitude. The mobile target moves from 33.38(deg.) in latitude and 126.55(deg.) in longitude to 33.37(deg.) in latitude and 125.54(deg.) in longitude during 101.00 seconds of travel time. The ATSM flights 314.88 kilometers with 50.0 meters of damage radius of the warhead. As a result of the simulation, the mission of the ATSM is succeed since mis-distance of the ATSM is 21.656 meters.

We had measured the computation time until SIMDIS[19] ASI file is generated as the log data. We also had set simulation sampling time(synchronization time unit) in the log data as 0.1 second. We do not consider network delay on this experiment since measurements of simulation computation time is changed depending on network environments. Fig. 7 presents the examples of screen shots on SIMDIS in our experiment, and Fig. 8 shows the comparison results.

Fig. 7. Screen shots on SIMDIS. (a) Flying scene of STSM (b) Blasting scene of STSM.

Fig. 8. The comparison results. (a) Our approach (b) Individual Simulations.

Fig. 9. An additional comparison results. (a) Our approach (b) Individual Simulations.

In this experiment, each simulation model requires Check Liveness Time(0.002 sec.) at the end of simulations. Our approach additionally consumes Control & P acket Forward Time(0.006 sec.) at every unit time(0.1 sec.) of simulations in order to synchronize simulation models. Therefore, the Control & P acket Forward Time is added to the computation time whenever status of simulation objects such as missile models are changed during the simulation time.

As the result of this experiment, we have saved the simulation computation time by 8.9367 seconds with our approach, and we have found out that each engagement is performed independently and adds their computation time with Checking Liveness of their simulation objects. It requires more computation time of simulations than our approach since our approach progresses in parallel. Therefore, as more simulators participate, the computation time that is saved will be increased in our approach.

As an additional experiment, we had added a phase array radar the above experiment. Therefore, the computation time of the radar, 35.2159 seconds, has been increased in the individual simulations as illustrated in Fig. 9-(b); however, there is finally no addition computation time in our approach as shown in Fig. 9-(a) due to the parallel progresses. In other words, we have saved the simulation time by 44.1526 seconds in the second experiment. In this case study, we do not discuss the detailed experiment data because of confidentiality reasons.

5. CONCLUSION

In this paper, we have attempted to solve the problem that the waiting time for time synchronization increases exponentially as the number of participating simulators increases in simulator interworking environments. The proposed method consists of preliminary processing phase and postprocessing phase. First, the preliminary processing phase divides simulation time into synchronization unit time in a simulation scenario combined by multiple simulations. Network packets from the multiple simulations are integrated as a set of events within synchronization unit time. In the post-processing phase, each simulator processes the generated events in parallel by referring to the integrated packet set during the synchronization unit time. Therefore, we can remove waiting time among these simulators. Moreover, the overall simulation time is also minimized as both preliminary processing and post-processing phases run in parallel. Finally, we have showed the practicality of our time-synchronization method through the experiments.

The points of our approach is taking advantages in that simulators constrainedly have a common simulation time. Depending on whether an event has occurred in one unified set of packets, the packet set can be discarded, and each simulator converts the object states based on the simulation progress time in order to eliminate the waiting time among simulators. Therefore, during the simulation time, it simulates events between simulation objects in different simulators as if they were in one simulation. For the future works, we plan to apply this technology into our previous Composite Combat Mission Planning Simulation Control System in the Composite Combat Mission Planning Simulation Environment(CCMPSE)[11] and the Mission Planning System for Multiple Ballistic Missiles [21].