Simulation method, apparatus, device, storage medium, and program product

Abstract

The application relates to the field of simulation technology and provides a simulation method, a simulation device, a simulation equipment, a storage medium and a program product. The method comprises the following steps: acquiring attribute information of each simulation event in a plurality of simulation events in a simulation task, the simulation task is used for simulating mutual influences among an application layer, a network layer and a physical layer in a communication network, and the attribute information of the simulation event comprises an expected trigger timestamp, a preceding execution condition and a dependency relationship with other simulation events; a causal relationship graph is constructed based on the attribute information of each simulation event; topological sorting is performed on the causal relationship graph to generate an execution sequence of each simulation event; and an execution instruction is sent to a simulation layer corresponding to each simulation event according to the execution sequence. The simulation method, the simulation device, the simulation equipment, the storage medium and the program product provided by the application can improve the timing consistency, the execution scheduling precision, the authenticity and the reliability of the overall simulation result of a cross-layer simulation task.

Description

Technical Field

[0001] This invention relates to the field of simulation technology, and in particular to a simulation method, apparatus, device, storage medium, and program product. Background Technology

[0002] Currently, a distributed simulation platform based on the 5G test range can simulate different parts of the 5G network (such as access network, core network, terminal equipment, etc.), realizing cross-layer simulation of the 5G network, that is, multi-layer simulation involving the physical layer to the application layer, thereby simulating and evaluating the performance, security, reliability and adaptability of the 5G network.

[0003] In relevant simulation platforms, timing issues of cross-layer events are typically addressed using static clock synchronization mechanisms. However, for complex cross-layer events, this static synchronization method often fails to effectively guarantee that events execute in the correct timing order. Especially in multi-layer simulations, the clock precision of each layer may differ, and clock asynchrony can lead to inconsistent event execution order, affecting the accuracy of simulation results. Summary of the Invention

[0004] This application provides a simulation method, apparatus, device, storage medium, and program product to solve the technical problem that inconsistencies in the execution order of events can easily occur during cross-layer simulation, thereby affecting the accuracy of simulation results.

[0005] In a first aspect, embodiments of this application provide a simulation method, including: The process involves acquiring attribute information for each simulation event within a simulation task. This task simulates the interactions between the application layer, network layer, and physical layer of a communication network. The attribute information for each simulation event includes the expected trigger timestamp, preconditions, and dependencies with other simulation events. Based on the attribute information of each simulation event, a causal relationship graph is constructed. Nodes in the causal relationship graph represent simulation events, and directed edges between nodes represent causal relationships between these events. A topological sort is performed on the causal relationship graph to generate the execution order of each simulation event. Execution instructions are then sent to the corresponding simulation layer according to the execution order.

[0006] In one embodiment, the simulation method further includes: In response to the detection of an update to the attribute information of the first simulation event, the updated attribute information of the first simulation event is obtained; the first simulation event is any existing simulation event or a newly added simulation event corresponding to the simulation task. Update the causal relationship graph based on the updated attribute information of the first simulation event; Re-perform topological sorting on the updated causal graph to generate the updated execution order.

[0007] In one embodiment, the attribute information further includes event type and resource requirements, whereby the resource requirements characterize the computing and communication resources required to execute the simulated event; the simulation method further includes: Based on the event type and resource requirements of the simulation event, as well as the network status of the simulation platform, the complexity assessment result of the simulation event is determined. Based on the complexity assessment results of the simulation events and the accuracy requirements of the simulation layer, the clock synchronization protocol and synchronization frequency corresponding to the simulation layer are determined.

[0008] In one embodiment, execution instructions are sent to the simulation layer corresponding to each simulation event in the execution order, including: Each simulation event is temporarily stored in a short-term buffer queue. Based on the causal dependencies of each simulation event and the load status of the simulation platform, the execution order of each simulation event in the short-term buffer queue is adjusted. Execution instructions are sent to the simulation layer corresponding to each simulation event according to the adjusted execution order.

[0009] In one embodiment, the simulation method further includes: Obtain the actual execution timestamps of each simulation event; Based on the actual execution timestamps and causal relationship graphs of each simulation event, a timing consistency verification result is generated. Based on the timing consistency verification results, update the clock synchronization strategy and event scheduling strategy.

[0010] In one embodiment, the simulation method further includes: Generate simulation reports corresponding to the simulation tasks. The simulation reports include the event execution sequence, the clock synchronization accuracy of each simulation layer, the causal relationship between each simulation event, and clock synchronization optimization suggestions.

[0011] Secondly, embodiments of this application provide a simulation device, including: The acquisition module is used to acquire the attribute information of each simulation event among multiple simulation events in the simulation task. The simulation task is used to simulate the interaction between the application layer, network layer and physical layer in the communication network. The attribute information of the simulation event includes the expected trigger timestamp, the pre-execution conditions, and the dependency relationship with other simulation events. The processing module is used to construct a causal relationship graph based on the attribute information of each simulation event; where the nodes in the causal relationship graph are simulation events, and the directed edges between the nodes in the causal relationship graph are the causal relationships between the simulation events. The processing module is also used to perform topological sorting on the causal relationship graph to generate the execution order of each simulation event; The sending module is used to send execution instructions to the simulation layer corresponding to each simulation event in the execution order.

[0012] Thirdly, embodiments of this application provide an electronic device, including a processor and a memory storing a computer program, wherein the processor executes the program to implement the steps of the simulation method described in the first aspect.

[0013] Fourthly, embodiments of this application provide a non-transitory computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of the simulation method described in the first aspect.

[0014] Fifthly, embodiments of this application provide a computer program product, including a computer program that, when executed by a processor, implements the steps of the simulation method described in the first aspect.

[0015] The simulation method, apparatus, device, storage medium, and program product provided in this application obtain attribute information such as the expected trigger timestamps, pre-execution conditions, and dependencies of cross-layer (application layer, network layer, and physical layer) simulation events in the communication network, and construct a causal relationship graph corresponding to nodes and directed edges accordingly. This allows for accurate and intuitive characterization of the logical and temporal relationships between complex cross-layer simulation events. Furthermore, by performing topological sorting on this causal relationship graph, the generated execution order is strictly guaranteed from a mathematical logic perspective to meet the sequential dependencies between events. Thus, issuing instructions to each simulation layer according to this coordinated execution order effectively avoids event execution errors caused by clock deviations or improper scheduling in traditional multi-layer independent simulations, significantly improving the temporal consistency, execution scheduling accuracy, and the realism and reliability of the overall simulation results of cross-layer simulation tasks. Attached Figure Description

[0016] To more clearly illustrate the technical solutions in this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0017] Figure 1 This is one of the flowcharts of the simulation method provided in the embodiments of this application.

[0018] Figure 2 This is the second flowchart of the simulation method provided in the embodiments of this application.

[0019] Figure 3This is the third flowchart of the simulation method provided in the embodiments of this application.

[0020] Figure 4 This is the fourth flowchart of the simulation method provided in the embodiments of this application.

[0021] Figure 5 This is the fifth flowchart illustrating the simulation method provided in the embodiments of this application.

[0022] Figure 6 This is a schematic diagram of the architecture of the simulation system according to an embodiment of this application.

[0023] Figure 7 This is an interactive diagram of the system layer modules in an embodiment of this application.

[0024] Figure 8 This is a flowchart illustrating the cross-layer event timing optimization method according to an embodiment of this application.

[0025] Figure 9 This is a schematic diagram of the simulation device provided in the embodiments of this application.

[0026] Figure 10 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this application. Detailed Implementation

[0027] To make the objectives, technical solutions, and advantages of this invention clearer, the technical solutions of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this invention. All other embodiments obtained by those skilled in the art based on the embodiments of this invention without creative effort are within the scope of protection of this invention.

[0028] Figure 1 This is one of the flowcharts illustrating a simulation method provided in an embodiment of this application. (Refer to...) Figure 1 This application provides a simulation method applicable to cross-layer collaborative simulation scenarios such as 5G network simulation and distributed simulation platforms. The method may include the following steps: Step 110: Obtain the attribute information of each simulation event among multiple simulation events within the simulation task.

[0029] The simulation task is used to simulate the interactions between the application layer, network layer, and physical layer within a communication network. For example, this communication network could be a 5G test range environment. A 5G test range is a highly simulated environment that supports multi-layered simulation of the physical layer (such as the wireless channel environment), the network layer (such as flow control), and the application layer (such as service throughput).

[0030] The attribute information of simulation events includes the expected trigger timestamp, prerequisite execution conditions, and dependencies with other simulation events. Users can configure simulation tasks when they start. This allows for the collection of data such as the expected trigger timestamp, event type, prerequisite conditions, and dependencies for each simulation event within the task. This data, combined with historical and real-time simulation data, lays the foundation for subsequent time-series management.

[0031] Step 120: Construct a causal relationship graph based on the attribute information of each simulation event.

[0032] In the causal relationship graph, the nodes are simulation events, and the directed edges between the nodes represent the causal relationships between the simulation events.

[0033] Specifically, a directed causal graph can be dynamically constructed using the collected event expected trigger timestamps and dependencies. For example, if event A must be executed before event B, a directed edge from event A to event B is generated in the graph. The causal graph can be continuously updated as new event data and simulation environment changes, ensuring that the causal relationships in the graph always reflect the latest state of the simulation environment, thereby ensuring that simulation events are executed according to causal relationships.

[0034] Step 130: Perform topological sorting on the causal relationship graph to generate the execution order of each simulation event.

[0035] In one embodiment, dynamic topological sorting can be performed in real time based on a dynamically updated causal relationship graph. For parallel events without direct dependencies, topological sorting can arrange these parallel events to be executed at the same time, avoiding unnecessary delays. For complex cross-layer events with multiple dependencies, topological sorting can flexibly handle the execution order of these events, ensuring the accuracy of timing. The sorted result is the global execution order of the simulation events.

[0036] For example, a dynamic topological sorting algorithm can be shown as follows: .

[0037] in, It is the execution order of the sorted simulation events. This is the current causal relationship diagram. This is a linear sorting algorithm that can be used for directed acyclic graphs.

[0038] Step 140: Send execution instructions to the simulation layer corresponding to each simulation event in the execution order.

[0039] Specifically, based on the topological sorting results of the causal relationship graph, event execution commands can be sequentially issued to simulation modules at each layer, such as the physical layer, network layer, and application layer. This ensures that cross-layer events are triggered and executed in the correct timing, and effectively solves the problem of event misalignment caused by differences in clock precision across multiple layers.

[0040] Figure 2 This is a second schematic flowchart illustrating a simulation method provided in an embodiment of this application. (Refer to...) Figure 2 Considering that the network state and event state change in real time during the simulation task execution, the simulation method provided in this application embodiment further includes: Step 210: In response to the detection of an update in the attribute information of the first simulation event, obtain the updated attribute information of the first simulation event.

[0041] The first simulation event is any existing simulation event or a newly added simulation event corresponding to the simulation task.

[0042] As an example, during the execution of a simulation task, a specific unexpected situation causes an increase in network latency at a certain layer, which changes the preconditions of a simulation event that was originally planned to be executed (such as the generation of application layer logs) (e.g., it is postponed). This simulation event can be regarded as the first simulation event, and the updated attribute information of the first simulation event can be obtained in real time.

[0043] Step 220: Update the causal relationship graph based on the updated attribute information of the first simulation event.

[0044] Specifically, it can check whether the preconditions of the first simulation event are met, and combine the updated expected timestamps or dependencies to dynamically update the initially constructed causal relationship graph in real time to reflect the real state of the current simulation environment.

[0045] Step 230: Re-execute topological sorting on the updated causal relationship graph to generate the updated execution order.

[0046] Specifically, as the causal relationships between simulation events change, the topological sorting can be re-executed in real time, automatically adjusting the execution order of all affected simulation events to ensure that the new event execution order conforms to the latest cross-layer causal relationships and avoids the impact of timing issues on simulation results.

[0047] As an example, suppose the following simulation events and dependencies occur during the execution of a simulation task: Event A: Network layer traffic monitoring (depends on events D and C); Event B: Firewall response (depending on event A); Event C: Application layer log generation (depends on event D); Event D: The firewall detected malicious traffic (no dependencies, earliest occurrence); Event E: Application layer analysis report (depends on event B); The dependencies between these simulation events during the execution of the simulation task are represented by a causal relationship graph. As new simulation event data is updated in real time, the topological sorting dynamically adjusts the order of event execution. The causal relationship graph can be seen as follows: Event D (The firewall detected malicious traffic → Event A (Network layer traffic monitoring)); Event C (Application layer log generation) → Event A (Network layer traffic monitoring); Event A (Network layer traffic monitoring) → Event B (Firewall response); Event B (Firewall Response) → Event E (Application Layer Analysis Report).

[0048] Among them, event D is the earliest event to occur. The simulation events that depend on event D are event A and event C.

[0049] Event A depends on events D and C, so event A will be executed after these two events are completed.

[0050] Event B depends on event A, so event B will only execute after event A has finished executing.

[0051] Event E depends on event B, so event E will only begin to execute after event B has finished executing.

[0052] After performing dynamic topological sorting based on the causal relationship graph, the following execution order can be obtained: Event D → Event C → Event A → Event B → Event E.

[0053] Event D executes first because it has no dependencies. Event C executes after event D completes. Event A executes after events D and C complete. Event B executes after event A completes. Event E executes after event B completes.

[0054] Furthermore, suppose that during the simulation task execution, due to some unforeseen circumstances, the dependencies of event A change, and event C may be postponed. In this case, the causal relationship graph can be updated in real time according to the new dependencies, and the topological sorting can be re-executed. Thus, if dependencies change (e.g., event C is postponed), the topological sorting will automatically adjust to ensure that the new event execution order conforms to the latest causal relationships. Moreover, through such dynamic topological sorting, the execution order of simulation events can be adjusted in real time, ensuring that each simulation event is executed correctly according to causal relationships, while effectively avoiding the impact of timing issues on the simulation results.

[0055] Figure 3 This is the third flowchart illustrating a simulation method provided in an embodiment of this application. (Refer to...) Figure 3 Considering that the accuracy of timing depends on the synchronization accuracy of the underlying clock, in order to improve the synchronization accuracy of the underlying clock, the simulation method provided in this application embodiment further includes: Step 310: Based on the event type and resource requirements of the simulation event, as well as the network status of the simulation platform, determine the complexity assessment result of the simulation event.

[0056] In one embodiment, the attribute information of the simulated event also includes the event type and resource requirements. The event type can be a large-scale distributed denial-of-service (DDoS) attack, routine traffic monitoring, etc. The resource requirements are used to characterize the computing and communication resources required for the execution of the simulated event.

[0057] The network state of a simulation platform can be used to characterize network load, latency, and jitter. The network state of the simulation platform positively impacts synchronization difficulty. When the network state is poor (e.g., high load, high latency, high jitter), the uncertainty of communication between cross-layer nodes increases, making existing clocks more prone to drift or inaccurate synchronization. Furthermore, to overcome this poor network state and maintain timing consistency, even a simple cross-layer event requires a higher cost to maintain synchronization, leading to increased complexity in synchronization requirements. Therefore, this scenario is characterized as having higher synchronization requirements during evaluation. Further, based on the higher complexity of the evaluation results, it can prompt the increase of the synchronization accuracy adjustment factor, triggering high-precision strategies. For example, increasing the synchronization frequency or directly switching from a low-precision protocol (e.g., Network Time Protocol (NTP)) to a high-precision protocol (e.g., Precision Time Protocol (PTP)) can offset the negative impact of poor network conditions.

[0058] In this way, the complexity of each simulation event can be dynamically evaluated by considering the event type and resource requirements of the simulation event, as well as the network status of the simulation platform.

[0059] Step 320: Based on the complexity assessment results of the simulation events and the accuracy requirements of the simulation layer, determine the clock synchronization protocol and synchronization frequency corresponding to the simulation layer.

[0060] In one embodiment, to ensure that simulation tasks can be executed accurately under different clock synchronization accuracy requirements, the synchronization accuracy of each simulation layer can be dynamically adjusted. For example, an adaptive synchronization accuracy adjustment algorithm can be used to dynamically adjust the synchronization frequency and synchronization protocol according to the clock synchronization accuracy requirements of each simulation layer, the complexity of simulation events, and the current network status, thereby finding a balance between simulation accuracy requirements and system resource consumption.

[0061] The input data for the adaptive synchronization accuracy adjustment algorithm may include the synchronization accuracy requirements (i.e., accuracy requirements) of each simulation layer, the current clock synchronization accuracy of each simulation layer, the complexity of simulation events, and the network status.

[0062] The synchronization accuracy requirement of the simulation layer refers to the synchronization accuracy requirements of the simulation layer's clock during the simulation task. For example, the physical layer may require nanosecond-level accuracy, the network layer requires microsecond-level accuracy, and the application layer may require millisecond-level accuracy. The current clock synchronization accuracy of the simulation layer is also the current synchronization accuracy of the simulation layer's clock. For example, the synchronization accuracy of the physical layer may be at the microsecond level, and the synchronization accuracy of the network layer may be at the millisecond level. Simulation event complexity refers to the complexity of the current simulation event. For example, high-complexity events include large-scale DDoS attacks, medium-complexity events include traffic analysis, and low-complexity events include routine traffic monitoring. Network status can include information such as the current network load of each simulation layer, inter-layer communication latency, and jitter.

[0063] The output data of the adaptive synchronization accuracy adjustment algorithm can include the synchronization frequency and synchronization protocol for each simulation layer. The synchronization frequency can be calculated based on the layer's synchronization accuracy requirements and the complexity of simulation events. The synchronization protocol can be selected according to accuracy requirements and network conditions; for example, PTP can be used for high accuracy, and NTP for low accuracy.

[0064] Specifically, the synchronization accuracy requirements of each simulation layer can be assessed based on the simulation workload. For example, the physical layer may require higher synchronization accuracy (e.g., nanosecond level), while the application layer can tolerate lower synchronization accuracy (e.g., millisecond level). The accuracy requirement of each simulation layer can be quantified by setting an accuracy factor. For example, nanosecond-level accuracy corresponds to an accuracy factor of 1, microsecond-level accuracy corresponds to an accuracy factor of 10, and millisecond-level accuracy corresponds to an accuracy factor of 100.

[0065] Based on the difference between the current actual synchronization accuracy and the required accuracy, a synchronization accuracy adjustment factor can be calculated. For example, an adaptive synchronization accuracy adjustment algorithm can be used to compare the current synchronization accuracy of the simulation layer with the required accuracy of that layer. By calculating the difference in accuracy factors, the system can dynamically adjust the synchronization frequency according to the difference. Furthermore, an adaptive synchronization accuracy adjustment algorithm can be used to calculate the synchronization accuracy adjustment factor. The synchronization accuracy adjustment factor can be used to characterize the impact of simulation event complexity and network state on synchronization accuracy. Specifically, as shown below: .

[0066] in, It is the synchronization accuracy adjustment factor of simulation layer i. and These are the weighting coefficients for the complexity of the simulation events and the network state. The complexity of the simulated event (e.g., the first value corresponds to high complexity, the second value corresponds to medium complexity, and the third value corresponds to low complexity). It refers to network status (such as load, latency, jitter). This refers to the synchronization accuracy requirements of simulation layer i (e.g., nanosecond level, microsecond level, etc.). It represents the current synchronization accuracy of simulation layer i. It is a weighting coefficient representing the difference between the actual synchronization accuracy and the accuracy requirement.

[0067] Furthermore, the synchronization frequency can be adjusted according to the synchronization accuracy adjustment factor, as shown below: .

[0068] in, It is the synchronization frequency adjusted by the simulation layer i. It is the default synchronization frequency of simulation layer i (e.g., the reference frequency of NTP or PTP). It is the synchronization accuracy adjustment factor.

[0069] Furthermore, a suitable synchronization protocol (such as PTP or NTP) can be selected based on the synchronization accuracy adjustment factor. If high synchronization accuracy is required (e.g., at the physical layer), the PTP protocol should be chosen. If lower synchronization accuracy is required (e.g., at the application layer), the NTP protocol should be used. The details are as follows: .

[0070] in, It is the synchronization protocol (e.g., PTP or NTP) selected by the simulation layer i. This is a threshold for synchronization accuracy. When the accuracy exceeds this threshold, the PTP protocol is selected. Otherwise, the NTP protocol is selected.

[0071] Furthermore, the adjusted synchronization frequency and synchronization protocol can be sent to each simulation layer to ensure that the clocks of all simulation layers are synchronized and meet the accuracy requirements of the simulation task.

[0072] Figure 4 This is the fourth flowchart illustrating a simulation method provided in an embodiment of this application. (Refer to...) Figure 4In step 140 above, i.e., when sending instructions to each simulation module according to the execution order, an optional implementation method including a buffering mechanism is provided, including: Step 410: Send each simulation event to a short-term buffer queue for temporary storage.

[0073] Specifically, short-term buffer queues are introduced in each simulation layer. The short-term buffer queue is used to temporarily store simulation events to be executed; that is, simulation events that need to be triggered for execution first enter the short-term buffer queue to wait for scheduling.

[0074] Step 420: Based on the causal dependencies of each simulation event and the load status of the simulation platform, adjust the execution order of each simulation event in the short-term buffer queue.

[0075] In one embodiment, a short-term buffer queue can be used to dynamically sort simulation events according to their dependencies, execution order, and system resource status. This allows the simulation system to respond more flexibly to simulation events of different priorities, complexities, and resource consumption, ensuring that high-priority events with met preconditions can be executed first, and minimizing the waiting time of low-priority events.

[0076] Step 430: Send execution instructions to the simulation layer corresponding to each simulation event according to the adjusted execution order.

[0077] Specifically, the preconditions for each simulation event can be checked sequentially according to the adjusted execution order. If the check passes, an execution command can be issued to the corresponding simulation module. If a simulation event's preconditions are not yet met (e.g., its dependent network layer simulation event has not completed), the simulation event will be postponed in a short-term buffer queue until its dependent simulation event completes. This ensures timing consistency again from the scheduling level.

[0078] In this way, simulation events can be temporarily stored in a short-term buffer queue, and the execution order of events can be dynamically adjusted, thereby avoiding delays and errors caused by resource limitations or inaccurate clock synchronization, and ensuring the consistency of timing again from the scheduling level.

[0079] Figure 5 This is the fifth flowchart illustrating a simulation method provided in an embodiment of this application. (Refer to...) Figure 5 To achieve closed-loop optimization through timing detection and report feedback, the simulation method provided in this application embodiment further includes: Step 510: Obtain the actual execution timestamp of each simulation event.

[0080] The actual execution timestamp of a simulation event refers to the timestamp that is added when the simulation event is triggered during the execution of the simulation task.

[0081] Specifically, at the end of each simulation cycle or when a simulation event is completed, the timestamps of each simulation event triggered during actual operation can be recorded and collected.

[0082] Step 520: Generate timing consistency verification results based on the actual execution timestamps and causal relationship graphs of each simulation event.

[0083] In one embodiment, the consistency between the actual execution timestamps of the simulated events and the dependency order specified in the causal relationship graph can be determined by comparing them. If an inconsistency is found (e.g., event B was executed before event A, but B depends on A in the graph), the simulated events that do not conform to the dependency relationship are automatically marked, and a timing inconsistency verification result is generated.

[0084] As an example, a timing consistency determination algorithm can be shown below: .

[0085] in, This is the result of the timing consistency check. The actual execution timestamp for each simulation event. This is a cause-and-effect diagram.

[0086] Step 530: Based on the timing consistency verification results, update the clock synchronization strategy and event scheduling strategy.

[0087] In one embodiment, if the timing consistency check results contain simulation events with inconsistent timing, the execution order of the simulation events and the clock synchronization frequency of the corresponding simulation layer can be automatically adjusted through an optimization strategy until the timing consistency is corrected. Simultaneously, the simulation event scheduling scheme can be updated to reduce timing deviations in future cycles, achieving closed-loop optimization. The optimization strategy could be to increase the synchronization frequency of the layer where the deviation occurs, or to switch from NTP to PTP.

[0088] Specifically, based on the timing consistency verification results, the clock synchronization strategy and event scheduling strategy can be automatically optimized to ensure that the execution order of events meets the simulation requirements. By adjusting the clock synchronization frequency in real time and correcting the event execution order, it can be ensured that events are executed in the correct order, thereby avoiding the impact of timing issues on the simulation results. Furthermore, the clock synchronization strategy can be dynamically adjusted according to feedback data and network status. For example, if the network latency is high, the clock synchronization frequency can be increased to ensure that the clock synchronization accuracy is guaranteed.

[0089] Furthermore, the scheduling order of simulation events can be intelligently adjusted based on the dependencies of simulation events and the timing consistency check results to avoid unnecessary scheduling delays. If the timing error has a significant impact, the clock synchronization strategy and event execution order can be adjusted to ensure that the logic in steps 110-140 above is executed cyclically within a limited number of iterations, thus correcting the timing inconsistency problem. Further, after each optimization, the system can perform a timing consistency check again. If a new inconsistency is detected, optimization can be performed again until the timing problem is corrected.

[0090] Therefore, at the end of each simulation cycle, a consistency check can be performed on the execution timing of simulation events in each simulation layer to ensure that all simulation events are executed in the correct order. If timing inconsistencies are found, the execution order of events and clock synchronization frequency can be automatically adjusted through optimization strategies to ensure that simulation events are executed in the correct timing sequence.

[0091] In one embodiment, the simulation method provided in this application further includes: generating a simulation report corresponding to the simulation task. The simulation report may include the event execution sequence, the clock synchronization accuracy of each simulation layer, the causal relationships between various simulation events, and clock synchronization optimization suggestions.

[0092] Event execution timing is used to record the actual execution order of all simulation events, including the actual execution timestamp and dependencies of each simulation event. When generating the simulation report, it can check whether each simulation event is executed according to the causal requirements, so as to indicate possible timing errors in the simulation report.

[0093] The simulation report can include clock synchronization accuracy information for each simulation layer to indicate whether each simulation layer has met the expected synchronization accuracy requirements. For simulation layers that do not meet the synchronization accuracy requirements, the specific degree of deviation can be indicated in the simulation report.

[0094] The simulation report can list the dependencies between simulation events in detail, ensuring that simulation events are executed according to the correct causal relationships. If causal relationship errors are found, the simulation report can be used to point out the problem and provide possible fixes.

[0095] If the timing error is caused by insufficient clock synchronization accuracy or other factors, the simulation report can be used to analyze factors such as clock synchronization frequency and network latency to identify the root cause of the error and provide optimization suggestions.

[0096] Specifically, after each simulation cycle, a simulation report corresponding to the simulation task can be generated. This report includes: event execution sequence (recording the actual execution order and deviations), clock synchronization accuracy of each simulation layer (indicating the specific degree of deviation and whether it meets the standard), causal relationships between various simulation events (pointing out causal errors and corrective measures), and clock synchronization optimization suggestions (such as analyzing physical layer clock deviations causing event delays and proposing suggestions to increase the synchronization frequency). In this way, the simulation report can provide more efficient and accurate strategy support for the next simulation task.

[0097] As an example, a simulation report may contain the following: Event execution sequence: Event A → Event B → Event C.

[0098] Clock synchronization accuracy: microseconds for the physical layer and milliseconds for the network layer.

[0099] Causal relationship determination: Event A successfully triggers event B, and event B successfully triggers event C.

[0100] Timing error: Physical layer clock skew causes event B to be delayed. Optimization suggestion: Increase synchronization frequency.

[0101] In one embodiment, the specific causes of timing errors can be analyzed based on timing issues in the simulation report, such as insufficient clock synchronization accuracy, network latency fluctuations, or incorrect dependencies. Furthermore, feedback analysis can be used to determine which factors need adjustment to ensure more accurate timing of simulated events in the next simulation cycle.

[0102] In one embodiment, if the simulation report shows that the clock accuracy of a simulation layer does not meet the requirements (e.g., the network layer clock deviation is large), the synchronization frequency of that simulation layer can be increased or the synchronization protocol can be switched. For example, a high-precision synchronization protocol (such as PTP) can be selected to replace a lower-precision synchronization protocol (such as NTP) in high-complexity simulation events.

[0103] In one embodiment, the synchronization frequency can be adjusted in a timely manner based on resource consumption information (such as bandwidth, computing load, etc.) in the simulation report to avoid unnecessary resource waste. For example, when the system load is high, the synchronization frequency can be reduced to balance clock synchronization accuracy and system resource consumption.

[0104] In one embodiment, based on timing feedback and simulation results, the synchronization strategy can be automatically adjusted according to optimization suggestions after the simulation task ends, and the next simulation cycle can be started according to the adjusted strategy. This process is a closed-loop feedback mechanism, and the timing accuracy will continuously improve as the simulation cycle progresses, ensuring the accuracy of the simulation results.

[0105] In one embodiment, Figure 6 This is a schematic diagram of the architecture of a simulation system according to an embodiment of this application. (Refer to...) Figure 6 The simulation system provided in this application embodiment can be divided into two main parts: the system layer and each specific simulation layer (including the application layer, network layer and physical layer).

[0106] Specifically, the system layer serves as the global control and scheduling hub, including a simulation event management module, a clock synchronization management module, a causal relationship analysis module, an event scheduling and execution module, and a feedback and optimization module.

[0107] The simulation event management module is used to receive and manage the input of simulation tasks, dynamically evaluate the complexity of each simulation event, and decide whether to activate the global clock synchronization strategy.

[0108] The clock synchronization management module is used to coordinate the clock synchronization strategies of each layer, and dynamically adjust the synchronization accuracy, synchronization protocol and synchronization frequency according to the complexity of simulation events and network status.

[0109] The causal relationship analysis module is used to collect timestamps, preconditions, and dependencies of simulation events in real time, dynamically build and update causal relationship graphs, and perform topological sorting to generate execution order.

[0110] The event scheduling and execution module is used to issue event execution instructions to each layer based on the event sorting results output by the causal relationship analysis module and the system status such as network load, and to manage short-term buffer queues.

[0111] The feedback and optimization module is used to collect the actual timestamps and feedback data of each simulation execution layer, perform timing consistency checks, and output optimization suggestions to the clock synchronization management module and the event scheduling and execution module based on the verification results, forming a closed loop.

[0112] At the specific simulation execution level, the simulation system can include three simulation layers: the application layer, the network layer, and the physical layer. Each layer has a corresponding simulation module deployed to receive instructions from the system layer and execute specific simulation tasks.

[0113] The application layer contains an application layer simulation module, which is used to execute application-level simulation events (such as business throughput, log generation, application layer analysis reports, etc.).

[0114] The network layer contains a network layer simulation module, which is used to execute network-level simulation events (such as flow control, firewall response, traffic monitoring, etc.).

[0115] The physical layer contains a physical layer simulation module, which is used to execute physical layer simulation events (such as wireless channel environment simulation), and in highly complex cross-layer events, its underlying clock is usually used as a reference for global clock synchronization.

[0116] In one embodiment, Figure 7 This is a schematic diagram illustrating the interaction of system layer modules according to an embodiment of this application. (Refer to...) Figure 7 In this embodiment of the simulation system, the core modules achieve close collaboration and closed-loop optimization through data flow and control flow.

[0117] Specifically, the simulation event management module is responsible for receiving simulation tasks and obtaining the attribute information of each event. After evaluation, it sends the event data to the causal relationship analysis module and outputs the complexity evaluation results to the clock synchronization management module.

[0118] The causal relationship analysis module constructs and dynamically updates the causal relationship graph based on the received event data (such as timestamps, dependencies, and preconditions), performs topological sorting, and then sends the generated event sorting instructions to the event scheduling and execution module.

[0119] Based on the received complexity assessment results (and factors such as network status), the clock synchronization management module determines the appropriate clock synchronization protocol and synchronization frequency, and sends the generated clock synchronization strategy adjustment instructions to the event scheduling and execution module (and each simulation layer) to ensure that the underlying clock achieves the required synchronization accuracy.

[0120] The event scheduling and execution module integrates the received event sequencing instructions and clock synchronization strategy adjustment instructions, issues execution instructions to each simulation module, and manages the short-term buffer queue. During or after event execution, the event scheduling and execution module sends the generated execution feedback data (such as the actual execution timestamp) to the feedback and optimization module.

[0121] The feedback and optimization module performs timing consistency checks and system state analysis based on the collected execution feedback data. The event scheduling and execution module generates and outputs targeted optimization strategies based on the analysis results, feeding these strategies back to the four core modules: the simulation event management module, the clock synchronization management module, the event scheduling and execution module, and the causal relationship analysis module. Through this multi-dimensional feedback mechanism, the simulation system can dynamically adjust event evaluation, clock synchronization, causal sequencing, and scheduling execution strategies in real time, thereby achieving closed-loop optimization of the entire simulation platform and ensuring timing consistency of cross-layer event execution.

[0122] In this way, through real-time interaction and dynamic adjustment of each module, it can be ensured that events at each layer in a complex simulation scenario can be accurately synchronized and executed in the correct order, ultimately optimizing the performance and efficiency of the simulation system.

[0123] In one embodiment, Figure 8 This is a flowchart illustrating the cross-layer event timing optimization method according to an embodiment of this application. (Refer to...) Figure 8The cross-layer event timing management and dynamic clock synchronization mechanism provided in this application embodiment can be divided into 4 steps and form a closed loop.

[0124] Specifically, step 1 is used for the basic configuration and dynamic adjustment of clock synchronization during system startup and operation, including: 1.1 Preliminary clock synchronization.

[0125] After the simulation system at each layer is deployed, a preliminary clock alignment is performed using standard protocols (such as NTP and PTP) to form an initial time base.

[0126] 1.2 Clock synchronization strategy switching mechanism.

[0127] Based on the complexity of the simulation events, the system intelligently decides whether a unified synchronization strategy is needed across all layers (e.g., using the physical layer clock as a global clock).

[0128] 1.3 Dynamically adjust the synchronization accuracy of each layer.

[0129] Based on the complexity of events, network status, and accuracy requirements of each layer, a synchronization accuracy adjustment factor is dynamically calculated to adjust the synchronization protocol and synchronization frequency of each layer.

[0130] Step 2, building upon Step 1, incorporates causal relationship analysis to ensure the precise execution order of cross-layer events. Specifically, this includes: 2.1. Simulation event complexity judgment.

[0131] The complexity level of an event is determined by assessing the event type, network status, and system resource consumption.

[0132] 2.2 Clock synchronization strategy selection and execution.

[0133] Based on the complexity assessment results, specific clock synchronization strategies are issued to ensure that the synchronization accuracy of clocks at each layer meets the requirements.

[0134] 2.3. Cross-layer event sorting.

[0135] Real-time collection of event information constructs a dynamically updated causal relationship graph, performs dynamic topological sorting, determines the strict execution order of each event, and combines short-term buffer queues for scheduling execution.

[0136] 2.4 Dynamic adjustment of clock synchronization strategy.

[0137] If a deviation is found between the actual sequence and the cause-effect graph during event execution, the clock synchronization strategy is corrected and optimized in real time through feedback.

[0138] Step 3 is used to verify and provide feedback on the timing at the end of each simulation cycle or during execution, specifically including: 3.1 Timing consistency detection.

[0139] By comparing the actual execution timestamps of each event with the causal relationship graph, we can check whether the execution order conforms to the predetermined dependencies.

[0140] 3.2 Timing optimization and feedback adjustment.

[0141] Based on the detection results, the clock synchronization frequency is automatically optimized, the synchronization protocol is switched, and the execution and scheduling order of events are adjusted to fix the timing inconsistency problem.

[0142] Based on this, the result of step 3 will proceed to step 4. Step 4 is used to generate a simulation report and implement closed-loop iteration, specifically including: 4.1 Simulation report generation.

[0143] Generate a comprehensive report that includes event execution timing, clock synchronization accuracy, causal relationship determination, and timing error analysis.

[0144] 4.2 Clock synchronization adjustment feedback.

[0145] The timing issues in the report are fed back to the system level to form a closed loop.

[0146] Based on this, the simulation system can determine whether timing consistency is met according to the simulation report and feedback data. If the determination result is yes, the current simulation task meets the requirements, and the process indicates the end of the simulation. If the determination result is no, it means that the current timing does not meet the requirements, and the simulation system will return to step 1 based on the optimization feedback to start a new round of dynamic clock synchronization and timing management closed-loop adjustment until the timing problem is fixed.

[0147] Based on the above embodiments, this application can solve problems such as timing consistency and event execution order in the simulation system by introducing a dynamic clock synchronization strategy switching mechanism, dynamic event sorting combining causal relationship graph and topological sorting, short-term buffer queue and closed-loop feedback mechanism, thereby significantly improving the accuracy of simulation results and the adaptability of the system.

[0148] The simulation device provided in the embodiments of this application is described below. The simulation device described below can be referred to in correspondence with the simulation method described above.

[0149] Figure 9 This is a schematic diagram of a simulation device provided in an embodiment of this application. (Refer to...) Figure 9 The simulation device provided in this application includes: The acquisition module 910 is used to acquire the attribute information of each simulation event among multiple simulation events in the simulation task. The simulation task is used to simulate the interaction between the application layer, network layer and physical layer in the communication network. The attribute information of the simulation event includes the expected trigger timestamp, the pre-execution conditions, and the dependency relationship with other simulation events. The processing module 920 is used to construct a causal relationship graph based on the attribute information of each simulation event; wherein, the nodes in the causal relationship graph are simulation events, and the directed edges between the nodes in the causal relationship graph are the causal relationships between the simulation events; The processing module 920 is also used to perform topological sorting on the causal relationship graph to generate the execution order of each simulation event; The sending module 930 is used to send execution instructions to the simulation layer corresponding to each simulation event in the execution order.

[0150] In one embodiment, the acquisition module 910 is further configured to acquire the updated attribute information of the first simulation event in response to detecting an update in the attribute information of the first simulation event; the first simulation event is any existing simulation event or a newly added simulation event corresponding to the simulation task. The processing module 920 is also used to update the causal relationship graph based on the updated attribute information of the first simulation event; The processing module 920 is also used to re-perform topological sorting on the updated causal relationship graph to generate an updated execution order.

[0151] In one embodiment, the attribute information also includes event type and resource requirements, whereby the resource requirements characterize the computing and communication resources required to execute the simulation event. The processing module 920 is also used to determine the complexity assessment results of the simulation event based on the event type and resource requirements of the simulation event, as well as the network status of the simulation platform. The processing module 920 is also used to determine the clock synchronization protocol and synchronization frequency corresponding to the simulation layer based on the complexity evaluation results of the simulation event and the accuracy requirements of the simulation layer.

[0152] In one embodiment, the sending module 930 is specifically used for: Each simulation event is temporarily stored in a short-term buffer queue. Based on the causal dependencies of each simulation event and the load status of the simulation platform, the execution order of each simulation event in the short-term buffer queue is adjusted. Execution instructions are sent to the simulation layer corresponding to each simulation event according to the adjusted execution order.

[0153] In one embodiment, the acquisition module 910 is further configured to acquire the actual execution timestamp of each simulation event; The processing module 920 is also used to generate timing consistency verification results based on the actual execution timestamps and causal relationship diagrams of each simulation event; The processing module 920 is also used to update the clock synchronization strategy and event scheduling strategy based on the timing consistency verification results.

[0154] In one embodiment, the processing module 920 is further configured to generate a simulation report corresponding to the simulation task. The simulation report includes the event execution sequence, the clock synchronization accuracy of each simulation layer, the causal relationship between each simulation event, and clock synchronization optimization suggestions.

[0155] Figure 10 An example is a schematic diagram of the physical structure of an electronic device, such as... Figure 10 As shown, the electronic device may include: a processor 1010, a communication interface 1020, a memory 1030, and a communication bus 1040, wherein the processor 1010, the communication interface 1020, and the memory 1030 communicate with each other via the communication bus 1040. The processor 1010 can call a computer program in the memory 1030 to execute the steps of the simulation method, such as including: The process involves acquiring attribute information for each simulation event within a simulation task. This task simulates the interactions between the application layer, network layer, and physical layer of a communication network. The attribute information for each simulation event includes the expected trigger timestamp, preconditions, and dependencies with other simulation events. Based on the attribute information of each simulation event, a causal relationship graph is constructed. Nodes in the causal relationship graph represent simulation events, and directed edges between nodes represent causal relationships between these events. A topological sort is performed on the causal relationship graph to generate the execution order of each simulation event. Execution instructions are then sent to the corresponding simulation layer according to the execution order.

[0156] Furthermore, the logical instructions in the aforementioned memory 1030 can be implemented as software functional units and, when sold or used as independent products, can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0157] On the other hand, this application also provides a computer program product, which includes a computer program that can be stored on a non-transitory computer-readable storage medium. When the computer program is executed by a processor, the computer can perform the steps of the simulation methods provided in the above embodiments, such as: The process involves acquiring attribute information for each simulation event within a simulation task. This task simulates the interactions between the application layer, network layer, and physical layer of a communication network. The attribute information for each simulation event includes the expected trigger timestamp, preconditions, and dependencies with other simulation events. Based on the attribute information of each simulation event, a causal relationship graph is constructed. Nodes in the causal relationship graph represent simulation events, and directed edges between nodes represent causal relationships between these events. A topological sort is performed on the causal relationship graph to generate the execution order of each simulation event. Execution instructions are then sent to the corresponding simulation layer according to the execution order.

[0158] On the other hand, embodiments of this application also provide a processor-readable storage medium storing a computer program for causing a processor to perform the steps of the methods provided in the above embodiments, such as including: The process involves acquiring attribute information for each simulation event within a simulation task. This task simulates the interactions between the application layer, network layer, and physical layer of a communication network. The attribute information for each simulation event includes the expected trigger timestamp, preconditions, and dependencies with other simulation events. Based on the attribute information of each simulation event, a causal relationship graph is constructed. Nodes in the causal relationship graph represent simulation events, and directed edges between nodes represent causal relationships between these events. A topological sort is performed on the causal relationship graph to generate the execution order of each simulation event. Execution instructions are then sent to the corresponding simulation layer according to the execution order.

[0159] The processor-readable storage medium can be any available medium or data storage device that the processor can access, including but not limited to magnetic memory (e.g., floppy disk, hard disk, magnetic tape, magneto-optical disk (MO)), optical memory (e.g., CD, DVD, BD, HVD), and semiconductor memory (e.g., ROM, EPROM, EEPROM, non-volatile memory (NAND FLASH), solid-state drive (SSD)).

[0160] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0161] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0162] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application.

Claims

1. A simulation method, characterized in that, include: The attribute information of each simulation event in a simulation task is obtained. The simulation task is used to simulate the interaction between the application layer, network layer and physical layer in a communication network. The attribute information of the simulation event includes the expected trigger timestamp, the pre-execution conditions, and the dependency relationship with other simulation events. Based on the attribute information of each simulation event, a causal relationship graph is constructed; wherein, the nodes in the causal relationship graph are simulation events, and the directed edges between the nodes in the causal relationship graph are the causal relationships between the simulation events; Perform topological sorting on the causal relationship graph to generate the execution order of each simulation event; Execution instructions are sent to the simulation layer corresponding to each simulation event in the order described.

2. The simulation method according to claim 1, characterized in that, Also includes: In response to the detection of an update to the attribute information of the first simulation event, the updated attribute information of the first simulation event is obtained; The first simulation event is any existing simulation event or a newly added simulation event corresponding to the simulation task; The causal relationship graph is updated based on the updated attribute information of the first simulation event; Re-perform topological sorting on the updated causal graph to generate the updated execution order.

3. The simulation method according to claim 1, characterized in that, The attribute information also includes event type and resource requirements, wherein the resource requirements characterize the computing and communication resources required to execute the simulation event; the method further includes: Based on the event type and resource requirements of the simulation event, as well as the network status of the simulation platform, the complexity assessment result of the simulation event is determined. Based on the complexity assessment results of the simulation events and the accuracy requirements of the simulation layer, the clock synchronization protocol and synchronization frequency corresponding to the simulation layer are determined.

4. The simulation method according to claim 1, characterized in that, The step of sending execution instructions to the simulation layer corresponding to each simulation event according to the execution order includes: Each simulation event is temporarily stored in a short-term buffer queue. Based on the causal dependencies of each simulation event and the load status of the simulation platform, the execution order of each simulation event in the short-term buffer queue is adjusted. Execution instructions are sent to the simulation layer corresponding to each simulation event according to the adjusted execution order.

5. The simulation method according to claim 1, characterized in that, Also includes: Obtain the actual execution timestamps of each simulation event; Based on the actual execution timestamps of each simulation event and the causal relationship graph, a timing consistency verification result is generated. Based on the timing consistency verification results, update the clock synchronization strategy and event scheduling strategy.

6. The simulation method according to claim 5, characterized in that, Also includes: Generate a simulation report corresponding to the simulation task. The simulation report includes the event execution sequence, the clock synchronization accuracy of each simulation layer, the causal relationship between each simulation event, and clock synchronization optimization suggestions.

7. A simulation device, characterized in that, include: The acquisition module is used to acquire the attribute information of each simulation event among multiple simulation events in the simulation task. The simulation task is used to simulate the interaction between the application layer, network layer and physical layer in the communication network. The attribute information of the simulation event includes the expected trigger timestamp, the pre-execution conditions, and the dependency relationship with other simulation events. The processing module is used to construct a causal relationship graph based on the attribute information of each simulation event; wherein, the nodes in the causal relationship graph are simulation events, and the directed edges between the nodes in the causal relationship graph are the causal relationships between the simulation events; The processing module is also used to perform topological sorting on the causal relationship graph to generate the execution order of each simulation event; The sending module is used to send execution instructions to the simulation layer corresponding to each simulation event in accordance with the execution order.

8. An electronic device comprising a processor and a memory storing a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the simulation method according to any one of claims 1 to 6.

9. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the simulation method as described in any one of claims 1 to 6.

10. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the simulation method according to any one of claims 1 to 6.

Images