Performance Measurement of DEVS Dynamic Structure on Forest Fire Spreading Simulation

Transcription

1 Performance Measurement of DEVS Dynamic Structure on Forest Fire Spreading Simulation Yi Sun, Xiaolin Hu Department of Computer Science Georgia State University Abstract---Traditional simulation methodology supports only changes in models state variables. Dynamic structure modeling allows to model both changes in state variables and changes in structure and has been applied to different applications. This paper focuses on the performance issue of dynamic structure implemented in the DEVS modeling and simulation environment. Six performance measurement metrics are defined. Measurement results and analysis are provided to evaluate the advantages and limitations of dynamic structure modeling in the context of forest fire spreading simulation. Index Terms DEVS, dynamic structure, forest fire spreading, performance metrics I. INTRODUCTION The motivation of dynamic structure models comes from the requirement of some applications, e.g., sociological and ecological applications. These application systems need dynamic structure capability to meet with structural changes in modeling and simulation. Generally, dynamic structure is useful for modeling living autonomous systems that change their interactions, compositions and behavior patterns to adapt to their environments, or those self-organizing, selfreconfiguring engineered systems, where the structures of the systems adapt to changed requirements. Many research on dynamic structure modeling have been based on the DEVS (Discrete Event Systems Specification) [2] modeling and simulation framework. DEVS has been introduced to support component-based modeling and simulation by emphasizing the theory of hierarchical modular modeling. In DEVS-based environment such as DEVSJAVA [3], a component is a model with clear defined interfaces. DEVS is a component system consisting of individual components and by establishing relationships among them. Such system has high degree of autonomy with well-defined interfaces, so that dynamic structure of components can be achieved during runtime. Barros in [5] presented the formalism on extended dynamic structure DEVS whose basic models are the same as classic DEVS basic models, but the structure of coupled models can change over time. The full and complete semantics for dynamic structure were added in classic DEVS. The dynamic capability supports changes ranging from simple linking relations between models, to more complex changes in model composition such as adding and deleting models during simulation. Dynamic structure DEVS provides several advantages: a) It provides a natural and effective way to model those complex systems which exhibit structure and behavior changes to adapt to different situations. Structure changing and component upgrading is an essential part of these systems. Without the dynamic structure capability, it s very hard, if not impossible, to model and simulate them. b) From the design point of view, dynamic structure provides the additional flexibility to design and analyze a system under development. c) Dynamic structure makes it possible to load only a sub-set of system s components for simulation. This is very useful to simulate very large systems with tremendous number of components, as only the active components need to be loaded dynamically to conduct the simulation. Otherwise, the entire system has to be loaded before the simulation begins. For example, as will be illustrated later, dynamic structure allows us to load only part of a cell space in forest fire spreading simulation. Dynamic structure has been applied to different applications. In [4], Dynamic Structure DEVS (DSDEVS) proved to be able to model a complex adaptive computer architecture. The work of [6] applied the DSDEVS to an example of fire spread simulation. In [7], the authors used dynamics structure to support the development of a dynamic team formation of robots. None of these works have explicitly measure the performance of dynamic structure modeling and simulation. In this paper, we discuss the dynamic structure implementation in DEVSJAVA environment and emphasize on its performance analysis by forest fire spreading experimentation. The structure of remaining paper is organized as follows. First, performance analysis and measurement metrics are presented in section II. Then in section III, the forest fire spreading experiment implementation is given and the experiment results related with performance metrics in section II are discussed in section IV. Finally, the conclusions and future work are presented in section V. II. PERFORMANCE ANALYSIS AND MEASUREMENT METRICS To develop performance measurement metrics for dynamic structure modeling and simulation, we start with the general simulation protocol as implemented by the coordinator in DEVSJAVA. Models.construction(); Models.initialization(); While (stop condition is not met){ simulators.askall( nexttn ) tn = compareandfindtn(); simulators.tellall("computeout,tn)

2 simulators.tellall("sendout") simulators.tellall("applydelt,tn) The simulation process first executes model construction and initialization. We call these two parts as initialization in later sections. Then the simulation goes into a while loop until simulation stops. In each while loop cycle (also referred to as simulation step in the following text), the simulators that are involved in this cycle go through the operations of nexttn(), computerout(), sendout(), and applydelt() following the semantics of DEVS models. Note that this simulation protocol applies to both dynamic structure (DS) and non-dynamic structure (non-ds). The difference between the two cases is that the number of simulators that are involved in the simulation cycle is different. For non-ds, the number of simulators is fixed; for DS, the number of simulators dynamically changes, due to the fact that models are dynamically added and deleted. Based on the above protocol, the total execution time can be counted as the time of initialization plus that of executing the while loop cycles. The initialization time depends on how many models need to be constructed and initialized before simulation starts. The execution time for the while loop depends on how many active models execute functions during the simulation cycles. To give a formal analysis about the execution time of DS model and non-ds model, a general formula is given below: T = T initial + Ti where, T is the total execution time. T initial includes the model construction and initialization time and T i is the execution time of one cycle; m_step is the total simulation cycles. The two parts shown in Formula () are related to DS and non-ds models in different ways. Consider the cellular spacebased forest fire spreading simulation (as described in Section III), where DS implementation uses a cellspacemanager to add/remove forest cells. For this application, initially there is only one component cellspacemanager and no forest cell in the cell space. Thus T initial is cellspacemanager s initial time. T i is the execution time for cycle i, which is the sum of the execution time for all the active cells plus overhead caused by adding/deleting cells at that cycle. So, T initial = t initial-of-cellspacemanager (2) Ti n ( tij + T overhead _ i j = ) In formula (3), tij is cycle execution time of an active cell. n is the number of active cells. T overhead_i consists of initialization of added cells and coupling/decoupling of added and deleted cells. The more number of added and deleted cells is, the larger T overhead_i is. For non-ds model, T initial is all cells initialization time. The cycle execution time includes active cells execution time and non-active cells execution time. So, the formulas are: T initial = N * t initial-of-cell (4) Ti = n j tij N n + j tij () (3) ' (5) In formula (5), tij is cycle execution time of an active cell; tij is cycle execution time of a non-active cell; N is the total number of cells in the cell space. Generally, tij < tij. For example, in the forest fire spreading simulation example described in section III, the value of tij / tij in is around /5 to 2/5. We note that for a particular cycle, the collection of active cells in DS and non-ds implementation is the same. Based on formulas (2), (3), (4) and (5), we get the execution time difference of non-ds and DS: T original - T DS = N * t initial-of-cell - t initial-of-cellspacemanager N n ( tij T overhead _ i j + ' ) Formula (6) shows that a major part of the difference of two models lies in non-ds model s non-active cells cycle execution time and DS model s overhead for adding/deleting cells. When the number of adding/deleting cells is small, the overhead is also small, thus the DS model s execution time performance is better than non-ds model; otherwise the DS model s execution time performance may be worse than that of the non-ds model. Based on the theoretical analysis above, some general observations can be made for the application of cellular spacebased forest fire spreading simulation. In general, we note that compared with the non-ds model, the DS implementation not only decreases execution time but also reduces memory utilization. On one hand, the DS forest fire model decreases execution time. The non-ds model creates all cells at the beginning of simulation, while the DS model only lets active cells exist during simulation. This improves simulation speed at least in two aspects: ) The dynamic structure saves time in the beginning. It does not necessarily create all cells at one time; furthermore, the average number of cells used in DS is much less than non-ds model. This advantage is more when the size of cell space becomes larger, e.g., the 6 * 6 cell space size vs. 2 * 2 cells space size. 2) The dynamic structure saves time during simulation. Since all cells exist in non-ds model, they need to execute internal, external, and output functions; but in DS model, only active (e.g., front fire burning) cells execute these functions, it saves passive cells execution time. The overhead of DS is the time of repeated adding/deleting cells and coupling connections. If non-ds model has a large number of cells to execute internal, external and output functions and DS model s overhead is small, DS is superior to non-ds model. On the other hand, the DS model reduces memory utilization. In DS model, only active (e.g. burning) cells exist in memory during whole simulation, while in non-ds model, all cells occupy memory all the time. So DS model s memory utilization is always less than non-ds model. To further support the above analysis, we develop the following six measurement metrics to compare the performance of DS and non-ds models. Experimental results are collected and presented in Section IV based on these metrics. Initialization time for different cellular space size Execution time for different cellular space size Execution time at different simulation stages Memory usage (6)

3 Execution time for different model behaviors (different # of points) Execution time for onedcoord, DS and non-ds models These metrics are developed based on two important factors for measuring simulation performance. One is execution time, and the other is memory utilization. The first metric is to compare initialization time of different cellular space size. The second metric is comparing execution time between non-ds and DS models on different cellular space size. This metric analyzes how cell space sizes affect DS performance. The third metric is detailed execution time analysis about non-ds model. In this metric, the total execution time, overhead, and added/deleted cells are presented and their relationship is pointed out. The fourth metric compares memory use of non- DS and DS models. The fifth metrics measures the execution time for different model behaviors, i.e., different types of models or the same model with different simulation scenarios. This measurement aims to show that the performance advantage/disadvantage of DS is really application-dependent. While some applications favor the DS, other may turn against the DS from the performance point of view. All these five metrics show DS model brings performance advantage by reducing the number of active cells in minimum. However, overhead is imported. In order to avoid the overhead of dynamically adding/removing cells but in the meantime to make only the active cells participate the simulation cycles, an improved simulation engine is developed in [8]. This simulation engine onedcoord uses a minseltree data structure to sort and find the active cells and then only those active cells go through the simulation cycles. So in the sixth metric, we compare onedcoord with DS and non-ds models. III. FOREST FIRE MODEL AND DYNAMIC STRUCUTRE IMPLEMENTATION In this section, we present our DS simulation for forest fire spreading model. Before that, a brief description of original non-ds model is presented. In original non-ds forest fire model, a forest is modeled as a two-dimensional cell-space composed of individual forest cells coupled together according to their relative physical geometric locations. Each cell is modeled as a twodimensional cell. Specifically, each cell has the following six states: unburned, burning, burned, unburned-wet, burning-wet, and burned-wet. Conditions and rules are defined to govern the state transition of a cell. In the two-dimensional cell space model, each cell has eight neighbor cells. Accordingly, for each cell, eight fixed fire spreading directions are defined. Fire spread in each cell is modeled using Rothermel s [9] stationary model, which is a one-dimension semi-empirical model. To obtain the second dimension, a propagation algorithm that uses maximum rate of spread and wind and slope factors is applied. During simulation, the behavior of a burning cell can be influenced by external inputs from neighboring cells as well as changes in weather conditions. In addition, uncertainty is incorporated in the model by allowing certain critical parameters to be sampled from arbitrary probability distributions during the simulation run. A detailed description of this model and the initial condition of simulation can be found in []. In non-ds model, all forest cells are created at the beginning of the simulation. This adds a lot of computation time for a cell space with thousands of cells. In order to avoid this, DS model creates active cells during simulation. Once a forest cell goes from an active state to a passive state, it is removed from the cell space. This approach only keeps the forest cells along the fire front. To achieve the implementation of the dynamic structure feature, we use DEVSJAVA and take advantage of its capability of dynamical adding/deleting components. In implementation, a DynamicCellSpaceManager model is used be responsible for structure change. It executes external function when there are requests from ForestCell. Part of the external method is shown as below. if (messageonport("inigniter",)) { getmessageonport( inigniter ); create and add fc object; addcouplings; holdin("ignite",.); if (messageonport( "inburning")) { getmessageonport( inburning ); create and add neighbor objects; addcouplings; holdin("added",.); if (messageonport("inburned")) { getmessageonport( inburned ); removemodel(cell.message); holdin("removed",); In ForestCell, two output ports outburning and outburned are defined. These two ports connect to DynamicCellSpaceManager s two input ports, inburning and inburned, separately. When an ForestCell burns, it sends out an adding message via its outburning port to DynamicCellSpaceManager s inburning port. In turn the DynamicCellSpaceManager adds its neighbor cells and adds coupling connections. When a cell is being burned, it sends out a delete message via its outburned port to DynamicCellSpaceManager, which deletes this cell from CellSpace. The process continues until the simulation ends. Since only active (burning) cells are considered in the cell space, this approach has the advantage of using less memory and leading to faster execution. During simulation, a data structure queue s is used to save information of burning cells and to guarantee all cells are added by DynamicCellSpaceManager only once. When a cell is burning and DynamicCellSpaceManager adds its neighbor cells in CellSpace, if the neighbor cell is a burning cell, it is in the queue, so DynamicCellSpaceManager will not add it.

4 Figure. Comparing the non-dynamic structure and dynamic structure implementation Figure shows fire-spreading display of DS and non-ds models. Three simulation stages are given. For the figures at the top row, the red cells are burning; the black cells are burned out; the pink cells are just ignited and transiting to the burning state; all other cells are unburned where different colors represent different fuel models. In the bottom row figures, the white spaces indicate that these cells (either unburned or burned out) are not loaded as part of the model. This comparison shows that the two implementations lead to the same simulation results. Figure also clearly shows the difference between the two implementation approaches. In the dynamic structure implementation, cells are dynamically added when they are about to be ignited by their neighbors, and removed when they are burned out. However, in the nondynamic structure implementation, all cells are loaded from the beginning and kept throughout the simulation. IV. PERFORMANCE MEASUREMENT RESULTS To test and detailed analyze DS performance, the same experiment frame of forest fire model is used in both non-ds and DS models. 6 metrics as described in section 2 are measured in this experimentation section. They are listed as follows. A. Initialization time for different cellular space size Table. Initialization Time (sec.) of Different Cellular Space Size C ellular Non-DS DS M odel Space Size M odel 2*2.7. 4* * Table shows the data of initialization time on 2*2, 4*4 and 6*6 cellular space. The initialization time of non-ds model increases with the increase of cellular space because non-ds model initialize all cells in cellular space at the beginning of simulation. But for DS model, the initialization time is little and does not change with the increase of cellular space size. From this point, DS model shows better performance on initialization than non-ds model. B. Execution time for different cellular space size The execution time is measured on simulation stages for different cellular space, which is depicted in figure 2(a). The speedup that is calculated by non-ds model s execution time divided by DS model s execution time is shown in figure 2(b). In these two figures, simulation stage is referred as the logical simulation time that is denoted by tn (e.g., stage 2 (S2) (tn: 8k) means simulation time period is from to 8). 3 curves for non-ds model and 3 curves for DS model on 2*2, 4*4 and 6*6 cellular space are displayed in figure 2(a). The non- DS 2*2 and DS 2*2 models finish simulation before stage 6 because small cell space runs out of simulation earlier than large cell space. When comparing the non-ds and DS model on the same cellular space, we see that non-ds model s execution time is larger than DS model at the same stage. This discipline is more obvious when cell space is large. Another discipline is that for the same model (e.g., non-ds or DS) and same stage, the execution time of larger cellular space is more than smaller cellular space at the same stage. In figure 2(b), speedup is displayed based on the data in figure 2(a). The speedup is almost in horizontal line. 6*6 cellular space s speedup is the largest. 4*4 cellular space s speedup is larger than 2*2. To analyze the reason behind description, we go back to formula (5) as introduced in earlier section. The non-ds model s cycle execution time consists of active cells and nonactive cells execution time. These two parts are different. The DS model s execution time consists of active cells execution time and overhead as described in formula (3). The difference lies in whether non-active cells execution time in non-ds model is larger than overhead in DS model or not. Therefore, on one hand, when the cellular space becomes larger, the nonactive cell s execution time increases and the proportion that overhead occupies decreases, so the speedup of small cellular space is smaller than large cellular space at same stage. On the other hand, for a certain cellular space size, the model behavior decides that in non-ds model, the proportion of nonactive cells execution time changes little and in DS model, the overhead proportion of execution changes little as well when simulation continues, so the speedup changes little correspondingly. Execution Time (s) Execution Time of non-ds and DS on Different Cell Space S (tn:4k) S2 (tn:8k) S3 (tn:2k) S4 (tn:6k) S5 (tn:2k) S6 (tn:24k) (non-ds)2*2 (non-ds)4*4 (non-ds)6*6 (DS)2*2 (DS)4*4 (DS)6*6 Speedup on Different Cell Space (a) (b) Figure 2. (a) Execution Time of Different Cellular Space (b) Speedup of Different Cellular Space C. Execution time at different simulation stages Detailed data about DS model is shown in figure 3. In this figure, simulation stages are intervals and they are continuous. Added/deleted number of cells, overhead and total execution time are displayed separately. From the figure, all four lines have the same trend, which means the rate of overhead and total execution time are similar with the rate of added/deleted cells. In this metric, we count the simulation time of DS model into two parts: time of active cells execution and time of overhead. The active cells execution time is proportional to the number of active cells. The overhead is due to the number of added/deleted cells. When simulation executes from early to later stage, the overhead increases because the number of added/deleted cells increases as well. Therefore, total Speedup S (tn:4k) S2 (tn:8k) S3 (tn:2k) S4 (tn:6k) S5 (tn:2k) S6 (tn:24k) 2*2 4*4 6*6

5 execution time increase. Note that the convex in stage 2 is caused by the model itself behavior, so the cumulative execution time from stage to stage 2 increases faster than other stage period, which is consistent with (DS)6*6 line in figure 2(a). In all, the execution time is proportional to the number of added/deleted cells. If the number of added/deleted cells becomes very large in some situation (e.g., later simulation stage), the execution time of DS model is possible to be greater than non-ds model. In such situation, the performance of DS model is worse than non-ds model. Execution Time (s) S (tn:-4k) Figure 3. Simulation Time Analysis (6 * 6 Cell Space Size) D. Memory usage Execution Time of 6*6 Cell Space Analysis S2 (tn:4k-8k) S3 (tn:8k-2k) S4 (tn:2k-6k) S5 (tn:6k-2k) S6 (tn:2k-24k) Added# (*) deleted# (*) Toverhead Execution time One of the most advantages of DS model is reducing memory use. In figure 4, the comparison of memory use between non-ds and DS model is presented. The top diagraph shows the result on different simulation stage about 6*6 cellular space. The bottom diagraph shows the result on different cellular space. In non-ds model, the active cells are always equal to cell space cells, so the memory using keeps in top line and does not change during simulation. In DS model, its active cells do not change much during whole simulation process, which is listed in table 2, so the memory using is in the bottom line and is less than non-ds model, as depicted in top diagraph of figure 4. On the other hand, DS model does not change with the increase of cellular space size. But for non-ds model, the memory use increases with the increase of cellular space. So when the cellular space size becomes very large, non-ds model has the deficiency about memory issue. DS model has no such limitations. Table 2. Active Cells of DS Model (6*6) S (tn:4k) S2 (tn:8k) S3 (tn:2k) S4 (tn:6k) S5 (tn:2k) S6 (tn:24k) # Active Cells E. Execution time for different model behaviors (multiple points) In this metric, we implement 2- and 4- in 4*4 cellular space for DS and non-ds models. The sparse and close behaviors are tested separately. In general, the execution time of non-ds model for sparse s is less than close s. The execution time of DS model for sparse s is more than close s. This is because in non-dynamic structure environment, sparse s cause fire spreading faster than close ; while in dynamic structure environment, sparse s lead to more overhead which is caused by added/deleted cells. The execution time comparison and the number of added/deleted cell for DS are listed in table 3 and table 4. The data of DS model in table 3 is consistent with data in table 4. The more number of added/deleted cells, the larger the execution time. Table 3. Execution Time (sec.) for Multiple Ignitions S (tn:4k) S2 (tn:8k) S3 (tn:2k) S4 (tn:6k) S5 (tn:2k) S6 (tn:24k) 2-sparse s(non-ds) close s(non-ds) sparse s(ds) close s(ds) sparse s(non-ds) close s(non-ds) sparse s(ds) close s(ds) Table 4. Added/Deleted Cells for DS Model (4*4) S (tn:4k) S6 (tn:24k) S2 (tn:8k) S3 (tn:2k) S4 (tn:6k) S5 (tn:2k) 2-sparse s(ds) 584/3 97/72 55/ /4 52/296 73/442 2-close s(ds) 523/273 97/689 53/ /4 56/ /442 4-sparse s(ds) 38/68 389/84 576/ /45 78/53 83/58 4-close s(ds) 65/343 7/ /4 426/25 65/37 78/57 Memory (MByte) Memory (MByte) Memory Use (6*6) non-ds 8 6 DS 4 2 S S2 S3 S4 S5 S6 (tn:4k) (tn:8k) (tn:2k) (tn:6k) (tn:2k) (tn:24k) Memory Use non-ds 8 DS *2 4*4 6*6 Cell Space Figure 4. Memory Use between non-ds and DS Models Speedup S (tn:4k) Speedup of Multiple Ignitions (4*4) S2 (tn:8k) S3 (tn:2k) S4 (tn:6k) S5 (tn:2k) S6 (tn:24k) Speedup of sparse 2- Speedup of close 2- Speedup of sparse 4- Speedup of close 4- Figure 5. Speedup of Multiple Ignitions Figure 5 shows the speedup. When multiple s are sparse, the speedup is decreased. If the behavior condition is same (e.g., sparse or close), the speedup of two s is

6 higher than four s. So the speedup is not only related with the added/deleted cells as stated in section C, but also has relationship with the behavior of model. In this case, the behavior means the sparse or close. F. Execution time for onedcoord, DS and non-ds models From the above analysis based on five measurement metrics, we know the simulation time is related with the cell space size, overhead and model structure behavior. The increase of overhead for DS model reduces its performance when simulation goes to later stages. In order to avoid this disadvantage, an improved simulation engine onedcoord is used. onedcoord uses the same idea as DS model to let only active cells execute simulation, but it has no overhead. The execution time comparison among non-ds, DS model and onedcoord is shown in figure 6. From the figure, onedcoord has much less simulation time compared with non-ds and DS models. Note that the initialization time of onedcoord is more than non-ds model because it initializes special data structure as well. The initialization time is listed in table 5. Even though onedcoord uses most initialization time, its total execution time is least. So onedcoord is the best choice from execution time aspect. Table 5. Initialization Time on 6*6 Cellular Space Initialization Time Execution Time (s) non-ds DS OneDCoord Execution Time of non-ds, DS and onedcoord (6*6) S (tn:4k) S2 (tn:8k) S3 (tn:2k) S4 (tn:6k) S5 (tn:2k) S6 (tn:24k) non-ds Figure 6. Execution Time for onedcoord, non-ds, and DS Models From memory point of view, onedcoord needs initialize all cells at the beginning, so its memory using is similar with non-ds model and even a little bit more because it needs extra memory for its special data structure. Detailed discussion about onedcoord can be referenced in [8]. DS onedcoord scale cellular space models such as the forest fire spreading simulation model studied in this paper, the number of added/deleted cells is typically small when compared to the total number of cells in the cell space. Thus DS is generally preferred for these applications. The performance (both memory and execution time) advantage of DS is especially apparent when the cell space size increases significantly. Since onedcoord has much better execution time performance than DS model and the memory use of DS model is better than onedcoord, one of our future work is to combine DS with onedcoord to get the best performance result on both memory and execution time aspects. REFERENCES [] Uhrmacher, A.M., Dynamic Structures in Modeling and Simulation - A Reflective Approach. ACM Transactions on Modeling and Simulation, Vol.. No.2, p , April 2. [2] Zeigler, B.P., T.G. Kim, and H. Praehofer.: Theory of Modeling and Simulation. 2 ed. 2, New York, NY: Academic Press [3] DEVS-Java Reference Guide, [4] B.P. Zeigler, T.G. Kim and C. Lee, Variable structure modelling methodology: An adaptive computer architecture example, Trans. Sot. Comput. Simulation 7 (4) (99) [5] Barros. F.J. Modeling Formalisms for Dynamic Structure Systems. ACM Transactions on Modeling and Computer Simulation, Vol. 7, No. 4, 5-55, 997 [6] Fernando J. Barros, Maria T. Mendes: Forest fire modelling and simulation in the DELTA environment. Simul. Pr. Theory 5(3): (997) [7] X. Hu, B. P. Zeigler, and S. Mittal, Variable Structure in DEVS Component-Based Modeling and Simulation, SIMULATION: Transactions of The Society for Modeling and Simulation International, Vol. 8, No. 2, pp. 9-2, 25 [8] X. Hu, and B. P. Zeigler: A High Performance Simulation Engine for Large-Scale Cellular DEVS Models, High Performance Computing Symposium (HPC'4), Advanced Simulation Technologies Conference, April 24 [9] Rothermel, R., A mathematical model for predicting fire spread in wildland fuels. Research Paper INT-5. Ogden, UT: U.S. Department of Agriculture, Forest Service, Intermountain Forest and Range Experiment Station, 972 [] Lewis Ntaimo, Bithika Khargharia A Cellular Devs Dynamic Fire Spread Simulation Model With An Optimized Cell Space, Project Report, Electrical and Computer Engineering Department, University of Arizona, May, 23 VI. CONCLUSIONS AND FUTURE WORK Dynamic structure capability provides a natural and effective way to model and simulate complex systems that exhibit structure, behavior, and interface changes to adapt to different situations. DEVS-based dynamic structure formalism supports hierarchical and modular modeling building, so it can be used to represent complex systems. In this paper, the performance measurement and analysis of both dynamic structure model and non-dynamic structure model are presented based on the forest fire spreading simulation. The analysis results show that from the memory point of view, DS model is always superior to non-ds model. But from the execution time point of view, DS may become slower than the non-ds if the number of added/deleted cells is large, which causes significant overhead. However, we note that for large