Multi-process firmware simulation operation method, device, equipment and storage medium

Abstract

The present invention relates to the field of solid-state hard disk testing technology, and in particular to a multi-process firmware simulation operation method, apparatus, device, and storage medium, wherein the method comprises: upon receiving an activity event of a process, determining the event type of the activity event; if the event type is an end event, determining whether there are parallel processes of the process in the resource space associated with the process; if there are parallel processes, determining the last end time of the preset end times of each parallel process; according to the last end time, determining the end time of the operation time axis of the firmware simulation, and ending the firmware simulation when the end time is reached. By determining the end time of the firmware simulation operation in real time through the activity event of the process, the firmware simulation operation can be exited immediately when the process operation ends, and the firmware simulation can be prevented from being terminated prematurely during the process operation, thereby solving the problem of unstable device operation under multi-core processes.

Description

Technical Field

[0001] The present invention relates to the field of solid-state hard drive testing technology, and in particular to a multi-process firmware simulation running method, device, equipment and storage medium. Background Art

[0002] Solid-state drives (SSDs) are hard drives made from arrays of solid-state electronic memory chips. Their fast read and write speeds have made them widely used in various electronic fields. Technical solutions for SSD testing typically utilize firmware emulation, which uses software to simulate the firmware environment for efficient and convenient analysis and vulnerability detection.

[0003] In related technical solutions, the firmware simulation process often involves multiple processes running in parallel. When multiple core processes are running in parallel, in order to avoid the device from mistakenly judging that the entire firmware simulation has ended when a certain process ends, an end time is usually preset. When the device reaches the end time, the firmware simulation run ends.

[0004] However, this approach suffers from the drawback that, during actual firmware emulation, all processes may have completed while the firmware emulation program is still running, resulting in a waste of device resources. Alternatively, the firmware emulation program may terminate prematurely while another process is still running, causing errors throughout the firmware emulation process. Consequently, current firmware emulation technology suffers from unstable device operation under multi-core processes.

[0005] The above content is only used to assist in understanding the technical solution of the present invention and does not constitute an admission that the above content is prior art. Summary of the Invention

[0006] The main purpose of the present invention is to provide a multi-process firmware simulation operation method, aiming to solve the problem of unstable device operation under multi-core processes.

[0007] To achieve the above object, the present invention provides a multi-process firmware simulation operation method, the method comprising:

[0008] Upon receiving an activity event of a process, determining an event type of the activity event;

[0009] If the event type is an end event, determining whether there is a parallel process of the process in the resource space associated with the process;

[0010] If the parallel process exists, determining the latest end time among the preset end times of the parallel processes;

[0011] According to the final end time, the running end time of the running time axis of the firmware simulation is determined, and when the running end time is reached, the firmware simulation is ended.

[0012] Optionally, when the process starts executing, the start event corresponding to the process is triggered, and when the process ends executing, the end event corresponding to the process is triggered.

[0013] Optionally, after the step of determining the event type of the activity event, the following steps are included:

[0014] If the event type is a start event, the firmware simulation is kept running, and when a new activity event is received, the step of determining the event type of the activity event is performed.

[0015] Optionally, after the step of determining whether there is a parallel process other than the process in the resource space associated with the process, the method further includes:

[0016] If the parallel process does not exist, determining the last end time of the serial process associated with the process;

[0017] The running end time is determined according to the last end time of the serial process.

[0018] Optionally, the step of determining the latest end time among the preset end times of the parallel processes includes:

[0019] Obtaining the preset end time of each of the parallel processes, and determining the corresponding end time on the execution timeline when the end event is received;

[0020] Determining the time interval between each of the preset end times and the end time corresponding to the end event;

[0021] A maximum time interval among the time intervals is determined, and the preset end time corresponding to the maximum time interval is used as the final end time.

[0022] Optionally, before the step of determining whether there is a parallel process other than the process in the resource space associated with the process, the method further includes:

[0023] When each of the processes starts executing, allocating a corresponding resource subspace to the process;

[0024] The step of determining whether there is a parallel process other than the process in the resource space associated with the process includes:

[0025] Determining whether there are other resource spaces in the resource space except the resource subspace corresponding to the process;

[0026] If the other resource space exists, it is determined that the parallel process exists in the resource space.

[0027] Optionally, the step of determining the running end time of the running time axis of the firmware simulation according to the final end time includes:

[0028] determining a time elapsed ratio between the operating timeline and the actual operating time of the device;

[0029] The operation end time is determined according to the time lapse ratio and the final end time.

[0030] In addition, to achieve the above-mentioned purpose, the present invention further provides a firmware simulation operation device, the firmware simulation operation device comprising:

[0031] An event receiving module, for determining an event type of an active event;

[0032] A parallel process detection module, configured to determine whether there are parallel processes other than the process in the resource space associated with the process;

[0033] An end time determination module, configured to determine the latest end time among the preset end times of each of the parallel processes;

[0034] The operation end determination module is used to determine the operation end time of the operation time axis of the firmware simulation according to the final end time, and end the firmware simulation when the operation end time is reached.

[0035] In addition, to achieve the above-mentioned purpose, the present invention also provides a firmware simulation device, which includes a memory, a processor, and a multi-process firmware simulation running program stored in the memory and capable of running on the processor. When the multi-process firmware simulation running is executed by the processor, the steps of the multi-process firmware simulation running method described above are implemented.

[0036] In addition, to achieve the above-mentioned purpose, the present invention also provides a computer-readable storage medium, on which a multi-process firmware simulation running program is stored. When the multi-process firmware simulation running program is executed by a processor, the steps of the multi-process firmware simulation running method as described above are implemented.

[0037] An embodiment of the present invention provides a multi-process firmware simulation operation method, apparatus, device and storage medium, wherein the method includes: upon receiving an activity event of a process, determining the event type of the activity event; if the event type is an end event, determining whether there are parallel processes of the process in the resource space associated with the process; if the parallel processes exist, determining the last end time among the preset end times of each of the parallel processes; according to the last end time, determining the end time of the operation time axis of the firmware simulation, and ending the firmware simulation when the end time is reached. By determining the end time of the firmware simulation operation in real time according to the activity event of the process, compared with the traditional method of directly setting a fixed end event point, the firmware simulation operation can be exited immediately when the process operation ends during the firmware simulation process, thereby avoiding waste of operation resources, and the firmware simulation can be prevented from being terminated prematurely during the process operation, thereby avoiding errors in the entire firmware simulation process, thereby improving the stability of the device operation under the multi-core process. BRIEF DESCRIPTION OF THE DRAWINGS

[0038] Figure 1 A schematic diagram of the hardware architecture of a firmware emulation device according to an embodiment of the present invention;

[0039] Figure 2 This is a flow chart of a first embodiment of a multi-process firmware simulation operation method of the present invention;

[0040] Figure 3 1. It is a flowchart of a second embodiment of the multi-process firmware simulation operation method of the present invention;

[0041] Figure 4 1 is a flow chart of a third embodiment of a multi-process firmware simulation operation method of the present invention;

[0042] Figure 5 Schematic diagram of the architecture of the firmware simulation running device of the present invention;

[0043] The purpose, features and advantages of the present invention will be further described with reference to the accompanying drawings and in conjunction with the embodiments. DETAILED DESCRIPTION

[0044] This application uses the active events of the process to determine the end time of the firmware simulation in real time. Compared with the traditional method of directly setting a fixed end event point, it can not only exit the firmware simulation immediately when the process ends during the firmware simulation process, avoiding waste of running resources, but also prevent the firmware simulation from being ended prematurely during the process, avoiding errors in the entire firmware simulation process, thereby improving the stability of device operation under multi-core processes.

[0045] To better understand the above technical solutions, exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although exemplary embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be limited by the embodiments described herein. Instead, these embodiments are provided to enable a more thorough understanding of the present disclosure and to fully convey the scope of the present disclosure to those skilled in the art.

[0046] As an implementation solution, the hardware architecture of the firmware emulation device can be as follows Figure 1 shown.

[0047] The embodiment of the present invention relates to a hardware architecture of a firmware emulation device, which includes a processor 101, such as a CPU, a memory 102, and a communication bus 103. The communication bus 103 is used to implement connection and communication between these components.

[0048] The memory 102 may be a high-speed RAM memory or a stable memory (non-volatile memory), such as a disk memory. Figure 1 As shown, the memory 102 as a computer-readable storage medium may include a multi-process firmware simulation running program; and the processor 101 may be used to call the multi-process firmware simulation running program stored in the memory 102 and perform the following operations:

[0049] Upon receiving an activity event of a process, determining an event type of the activity event;

[0050] If the event type is an end event, determining whether there is a parallel process of the process in the resource space associated with the process;

[0051] If the parallel process exists, determining the latest end time among the preset end times of the parallel processes;

[0052] According to the final end time, the running end time of the running time axis of the firmware simulation is determined, and when the running end time is reached, the firmware simulation is ended.

[0053] In one embodiment, the processor 101 may be configured to call a multi-process firmware simulation running program stored in the memory 102 and perform the following operations:

[0054] If the event type is a start event, the firmware simulation is kept running, and when a new activity event is received, the step of determining the event type of the activity event is performed.

[0055] In one embodiment, the processor 101 may be configured to call a multi-process firmware simulation running program stored in the memory 102 and perform the following operations:

[0056] If the parallel process does not exist, determining the last end time of the serial process associated with the process;

[0057] The running end time is determined according to the last end time of the serial process.

[0058] In one embodiment, the processor 101 may be configured to call a multi-process firmware simulation running program stored in the memory 102 and perform the following operations:

[0059] Obtaining the preset end time of each of the parallel processes, and determining the corresponding end time on the execution timeline when the end event is received;

[0060] Determining the time interval between each of the preset end times and the end time corresponding to the end event;

[0061] A maximum time interval among the time intervals is determined, and the preset end time corresponding to the maximum time interval is used as the final end time.

[0062] In one embodiment, the processor 101 may be configured to call a multi-process firmware simulation running program stored in the memory 102 and perform the following operations:

[0063] When each of the processes starts executing, allocating a corresponding resource subspace to the process;

[0064] The step of determining whether there is a parallel process other than the process in the resource space associated with the process includes:

[0065] Determining whether there are other resource spaces in the resource space except the resource subspace corresponding to the process;

[0066] If the other resource space exists, it is determined that the parallel process exists in the resource space.

[0067] In one embodiment, the processor 101 may be configured to call a multi-process firmware simulation running program stored in the memory 102 and perform the following operations:

[0068] determining a time elapsed ratio between the operating timeline and the actual operating time of the device;

[0069] The operation end time is determined according to the time lapse ratio and the final end time.

[0070] Based on the hardware architecture of the above-mentioned firmware simulation device based on solid-state drive testing technology, an embodiment of the multi-process firmware simulation running method of the present invention is proposed.

[0071] Reference Figure 2 In a first embodiment, the multi-process firmware simulation operation method includes the following steps:

[0072] Step S10, upon receiving an activity event of a process, determining the event type of the activity event;

[0073] In this embodiment, when a firmware emulation device (hereinafter referred to as the device) receives an activity event of a process during the execution of firmware emulation, the event type of the activity event is determined. An activity event is an operation log that records the operation records at certain key nodes during the firmware emulation process. The activity event includes a timestamp and relevant identification information of the process. When receiving the activity event, the device can determine the corresponding time point on the running timeline set during the firmware emulation process based on the timestamp.

[0074] In this embodiment, the event types involved include start events and end events. Start events are characterized as activity events triggered at the beginning of a process's execution. End events are characterized as activity events triggered at the end of a process's execution. It should be noted that since activity events contain timestamps, the timestamp corresponding to the start event is the start time of the process, while the timestamp corresponding to the end event is the end time of the process. Therefore, by determining the start and end events of a process, the start and end times of the process can be determined accordingly.

[0075] Step S20: If the event type is an end event, determine whether there is a parallel process of the process in the resource space associated with the process;

[0076] In this embodiment, after determining the event type of the active event, if the event type corresponding to the active event of the process is determined to be an end event, the process's associated resource space is then determined to determine whether there are any parallel processes associated with the process other than the process itself. The resource space is the memory space allocated by the device for the entire firmware emulation program when the firmware emulation is running. For parallel processes, due to limited memory resources, the more parallel processes there are, the smaller the resource subspace allocated to each process. When one of the multiple parallel processes ends, the resource subspaces of the other processes will become relatively larger. In other words, the size of the resource subspace is negatively correlated with the number of parallel processes. In most cases, the sum of the resource subspaces corresponding to the individual parallel processes should be less than the resource space occupied by the entire firmware emulation. It should be noted that in this embodiment, parallel processes are characterized as processes running simultaneously. However, the start and end times of different parallel processes may be the same or different, and the execution times of different parallel processes may be the same or different. This is not limited in this embodiment.

[0077] Optionally, determining whether parallel processes exist within the resource space can be based on the number of resource subspaces within the entire resource space. Since each process is assigned a corresponding resource subspace upon initiation of execution based on its data volume and / or weight, and multiple parallel processes occupy the entire resource space when multiple resource subspaces exist within the resource space in addition to the resource subspace for the process in question, it is determined that parallel processes exist within the firmware emulation process.

[0078] For example, in a specific embodiment, the proportion of resource space during the entire firmware operation process is output in the form of a visual interface to a display window of a display interface. The display window can display the processes running during the firmware operation process. When there are more than one process displayed, the device determines that there are parallel processes in the firmware simulation process at this time.

[0079] Step S30: If the parallel process exists, determine the latest end time among the preset end times of the parallel processes;

[0080] In this embodiment, after determining whether there are parallel processes, if it is determined that there are parallel processes in the firmware simulation process, the preset end time of each parallel process is determined, and then the latest end time that ends is determined from each preset end time. In this embodiment, since the firmware simulation simulates the actual operation of the firmware in the form of software, during the simulation operation, a large number of processes are quickly and frequently executed by the firmware simulation program, thereby simulating the hardware aging of the firmware under long-term operation. In this embodiment, each simulated process is assigned a preset end time at the beginning of execution, and the end time is the theoretical shortest running time of the process. It should be noted that the preset end time is a theoretical value. During the actual operation of the process, the actual running time may be greater than or less than the preset end time due to the occupancy of resource space. Therefore, the determined final end time is also a theoretical value.

[0081] Optionally, the method for determining the latest end time among the preset end times of each parallel process can be: obtaining the preset end time of each parallel process, and determining the corresponding end time on the running timeline when the end event is received, and then determining the time interval between each preset end time and the end time point, and then determining the maximum time interval among each time interval, and taking the preset end time corresponding to the maximum time interval as the latest end time.

[0082] Step S40: determining the end time of the firmware simulation operation time axis according to the final end time, and ending the firmware simulation when the end time is reached.

[0083] In this embodiment, after determining the final end time, the end time of the firmware simulation runtime axis is determined based on the final end time, so that the entire firmware simulation process ends when the device reaches the end time. The runtime time axis is a horizontally scrolling time axis program simulated by the device during the firmware simulation process, which can simulate the passage of time in the real world.

[0084] Optionally, since firmware simulation simulates the operation aging of firmware over a long period of time in a short period of time, in order to improve the reliability of firmware simulation, the operation timeline in this embodiment can also set a time lapse ratio compared to the actual operation time of the device firmware, and determine the operation end time based on the time lapse ratio and the final end time.

[0085] Exemplarily, in some specific embodiments, the time lapse ratio between the running timeline and the actual running time of the device firmware in the real world can be 60:1, that is, 1s in the real world corresponds to 1min on the running timeline. When the final end time is determined to be 18:00, if the time on the running timeline at this time is 16:00, the firmware simulation ends after two minutes.

[0086] Of course, in other specific implementations, the ratio of the running timeline to the time elapsed in the real world can also be equal to 1: 1. For example, if the final end time is determined to be 18:00, if the time on the running timeline at this time is 16:00, then the firmware simulation ends after two hours.

[0087] Optionally, in some embodiments, after determining the end time of the firmware emulation runtime axis and before reaching the end time, if a new activity event is received within this time period, the process returns to the step of determining the event type of the activity event. That is, after receiving the new activity event, the firmware emulation runtime is re-determined.

[0088] In the technical solution provided in this embodiment, when an activity event of a process is received, the event type of the activity event is determined. When the event type is an end event, it is determined whether there are parallel processes other than the process in the resource space associated with the process. If there are parallel processes, the last end time of the preset end time of each parallel process is determined. Finally, based on the last end time, the end time of the operation of the operation time axis of the firmware simulation is determined, so that the firmware simulation is ended when the end time of the operation is reached. By determining the end time of the firmware simulation in real time based on the activity event of the process, compared with the traditional method of directly setting a fixed end event point, the firmware simulation can be exited immediately when the process ends during the firmware simulation process, thereby avoiding waste of operation resources, and the firmware simulation can be prevented from being ended prematurely during the process, thereby avoiding errors in the entire firmware simulation process, thereby improving the stability of the device operation under the multi-core process.

[0089] Reference Figure 2 In the second embodiment, based on the first embodiment, after step S10, the following steps are included:

[0090] Step S50: If the event type is a start event, keep the firmware simulation running, and when a new activity event is received, perform the step of determining the event type of the activity event.

[0091] Optionally, in this embodiment, after determining the event type of the active event, if it is determined that the event type is a start event, the firmware simulation is kept running, and when a new active event is received, step S10 is re-executed. When the determined event type is a start event, it is characterized as the start of the process running. At this time, there is no need to update the end time of the process. The firmware simulation process keeps running, and the end time of the running timeline is kept at the end time initially set. When a new active event is received again, the time type of the new active event is determined, wherein, if it is still a start event, the firmware simulation is kept running, and if the active time type is an end event, step S20 is executed.

[0092] In the technical solution provided in this embodiment, after determining the event type of the active event, if the determined event type is the start time, the firmware simulation is kept running, and the end time of the timeline is also kept at the original end time. When the active event is received again, the event type of the active event is determined again until the event type is the end time, and then the end time update operation of the timeline described in the first embodiment is executed, thereby improving the stability of the device operation under the multi-core process.

[0093] Reference Figure 3 In a third embodiment, based on any embodiment, after step S20, the following steps are included:

[0094] Step S60: If the parallel process does not exist, determine the last end time of the serial process associated with the process;

[0095] Step S70: determining the running end time according to the last end time of the serial process.

[0096] Optionally, in this embodiment, after determining whether there is a parallel process of the process, if no parallel process exists, the process proceeds to find the last end moment in the serial process of the process, and the running end time of the running time axis of the firmware simulation is determined based on the last end moment in the serial process. In this embodiment, the serial process is characterized as a process that is executed after the execution of the process corresponding to the end event is completed. One of the differences between a serial process and a parallel process is that a serial process allocates the corresponding resource subspace to the next serial process after the previous serial process ends and releases its resource subspace. Therefore, the last end moment of the serial process corresponds to the end moment of the last executed serial process, and the running end time of the running time axis is determined based on the last end moment.

[0097] In the technical solution provided by this embodiment, if no parallel processes exist within the resource space associated with a process, the system searches for the final end time of the serial process associated with the process and uses this final end time as the end time of the execution timeline. Thus, firmware emulation ends when this end time is reached. This improves the stability of device operation under multi-core processes.

[0098] In addition, refer to Figure 4 This embodiment further provides a firmware simulation running device, the firmware simulation running device comprising:

[0099] An event receiving module 100 is used to determine the event type of the activity event;

[0100] A parallel process detection module 200 is used to determine whether there are parallel processes other than the process in the resource space associated with the process;

[0101] An end time determination module 300 is configured to determine the latest end time among the preset end times of the parallel processes;

[0102] The operation end determination module 400 is used to determine the operation end time of the operation time axis of the firmware simulation according to the final end time, and end the firmware simulation when the operation end time is reached.

[0103] Furthermore, those skilled in the art will appreciate that all or part of the process steps in the method of the above-described embodiment can be implemented by instructing the relevant hardware through a computer program. The computer program includes program instructions, which can be stored in a storage medium that is a computer-readable storage medium. The program instructions are executed by at least one processor in the firmware emulation device to implement the process steps of the above-described method embodiment.

[0104] Therefore, the present invention also provides a computer-readable storage medium, which stores a multi-process firmware simulation running program. When the multi-process firmware simulation running program is executed by a processor, it implements the various steps of the multi-process firmware simulation running method described in the above embodiment.

[0105] The computer-readable storage medium may be any computer-readable storage medium that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a magnetic disk, or an optical disk.

[0106] It should be noted that, in this document, the terms "comprises," "includes," or any other variations thereof are intended to encompass non-exclusive inclusion, such that a process, method, article, or apparatus comprising a series of elements includes not only those elements but also other elements not explicitly listed, or elements inherent to such process, method, article, or apparatus. In the absence of further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of other identical elements in the process, method, article, or apparatus comprising the element.

[0107] Through the description of the above embodiments, those skilled in the art can clearly understand that the above embodiment methods can be implemented by means of software plus the necessary general hardware platform, and of course can also be implemented by hardware, but in many cases the former is a better embodiment. Based on this understanding, the technical solution of the present invention is essentially or the part that contributes to the prior art can be embodied in the form of a software product, which is stored in a computer-readable storage medium (such as ROM / RAM, magnetic disk, optical disk) as described above, and includes a number of instructions for enabling a terminal device (which can be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in each embodiment of the present invention.

[0108] The above are only preferred embodiments of the present invention and are not intended to limit the patent scope of the present invention. Any equivalent structure or equivalent process transformation made using the contents of the present invention description and drawings, or directly or indirectly applied in other related technical fields, are also included in the patent protection scope of the present invention.

Claims

1. A multi-process firmware simulation operation method, characterized in that: The multi-process firmware simulation method includes: Upon receiving an activity event of a process, determining an event type of the activity event; If the event type is an end event, determining whether there is a parallel process of the process in the resource space associated with the process; If the parallel process exists, determining the latest end time among the preset end times of the parallel processes; Determining an operation end time of an operation time axis of the firmware simulation according to the final end time, and ending the firmware simulation when the operation end time is reached; Before the step of determining whether there is a parallel process other than the process in the resource space associated with the process, the method includes: When each of the processes starts executing, allocating a corresponding resource subspace to the process; The step of determining whether there is a parallel process other than the process in the resource space associated with the process includes: Determining whether there are other resource spaces in the resource space except the resource subspace corresponding to the process; If the other resource space exists, it is determined that the parallel process exists in the resource space.

2. The multi-process firmware simulation operation method according to claim 1, wherein: When the process starts executing, the start event corresponding to the process is triggered, and when the process ends executing, the end event corresponding to the process is triggered.

3. The multi-process firmware simulation operation method according to claim 1, wherein: After the step of determining the event type of the activity event, the method further includes: If the event type is a start event, the firmware simulation is kept running, and when a new activity event is received, the step of determining the event type of the activity event is performed.

4. The multi-process firmware simulation operation method according to claim 3, wherein: After the step of determining whether there is a parallel process other than the process in the resource space associated with the process, the method includes: If the parallel process does not exist, determining the last end time of the serial process associated with the process; The running end time is determined according to the last end time of the serial process.

5. The multi-process firmware simulation operation method according to claim 1, wherein: The step of determining the latest end time among the preset end times of the parallel processes comprises: Obtaining the preset end time of each of the parallel processes, and determining the corresponding end time on the execution timeline when the end event is received; Determining the time interval between each of the preset end times and the end time corresponding to the end event; A maximum time interval among the time intervals is determined, and the preset end time corresponding to the maximum time interval is used as the final end time.

6. The multi-process firmware simulation operation method according to claim 1, wherein: The step of determining the end time of the firmware simulation operation time axis according to the final end time includes: determining a time elapsed ratio between the operating timeline and the actual operating time of the device; The operation end time is determined according to the time lapse ratio and the final end time.

7. A multi-process firmware simulation running device, characterized in that: The multi-process firmware simulation running device includes: An event receiving module, configured to determine an event type of an activity event upon receiving an activity event of a process; a parallel process detection module configured to, if the event type is an end event, determine whether there are parallel processes other than the process in the resource space associated with the process; before the step of determining whether there are parallel processes other than the process in the resource space associated with the process, the parallel process detection module is further configured to allocate a corresponding resource subspace to each process when the process starts executing; the step of determining whether there are parallel processes other than the process in the resource space associated with the process comprises: determining whether there are other resource spaces in the resource space other than the resource subspace corresponding to the process; and if the other resource spaces exist, determining that the parallel process exists in the resource space; an end time determination module, configured to determine the latest end time among the preset end times of the parallel processes if the parallel processes exist; The operation end determination module is used to determine the operation end time of the operation time axis of the firmware simulation according to the final end time, and end the firmware simulation when the operation end time is reached.

8. A firmware simulation device, characterized in that: The firmware simulation device includes: a memory, a processor, and a multi-process firmware simulation running program stored in the memory and runnable on the processor. When the multi-process firmware simulation running program is executed by the processor, the steps of the multi-process firmware simulation running method as described in any one of claims 1 to 6 are implemented.

9. A computer-readable storage medium, characterized in that The computer-readable storage medium stores a multi-process firmware simulation running program, which, when executed by a processor, implements the steps of the multi-process firmware simulation running method according to any one of claims 1 to 6.

Images