Method and device for debugging embedded operating system

Abstract

The invention relates to a method and a device for debugging an embedded operating system, and belongs to the technical field of software. Based on a source code program library of an embedded operating system, all program calling relations in the source code program library are marked, and a program running path map is established; performing active verification according to a function interface of debugging hardware, and recording program running performance calling data under a program running path of each interface in the program running path map; screening out a hot program running process in the program running performance calling data, and recording the hot program running process as a core node of the program running process to be debugged; optimizing strategies are generated according to the performance calling execution requirements of the core node of the running process of the program to be debugged, and the benefit score of each optimizing strategy is calculated; and screening out the maximum benefit score value of the optimization strategy as the optimization strategy of the core node of the running process of the program to be debugged. The method has the advantage that the operation efficiency and the stability of the embedded operation system are effectively improved.

Description

Technical Field

[0001] The invention belongs to the field of software technology, and in particular relates to a method and device for debugging an embedded operating system. Background Art

[0002] Embedded Operating System (EOS) refers to an operating system specifically used for embedded systems. Embedded systems usually refer to non-desktop computer systems, that is, non-PCs, servers, large, medium and small computers, etc., but computer equipment or devices with computer functions that can be "embedded" into special equipment and perform special functions.

[0003] At present, the conventional idea is to set breakpoints in the internal execution code of the embedded system for detection. However, the manual detection process is time-consuming and labor-intensive, and it is very easy to ignore logical errors in the program. As a result, the carrier of the embedded system has no abnormalities during the initial use, but as time goes by, the stability of the carrier decreases and crashes. There is no standard solution for the identified problems, so the debugged embedded system carrier is affected by human experience and the quality is inconsistent. Summary of the invention

[0004] 1. Technical issues to be resolved

[0005] The technical problem to be solved by the present invention is how to provide a method and device for debugging an embedded operating system to solve the problem that the current conventional idea is to set breakpoints on the internal execution code of the embedded system for detection, but the manual detection process is time-consuming and labor-intensive and it is very easy to ignore logical errors in the program, resulting in the carrier of the embedded system having no abnormalities during initial use, but as time goes by, the stability of the carrier decreases and crashes, and there is no standard solution to the identified problem, so that the carrier of the debugged embedded system is affected by human experience and has inconsistent quality.

[0006] (II) Technical solution

[0007] In order to solve the above technical problems, the present invention proposes

[0008] A method for debugging an embedded operating system, characterized in that the method comprises the following steps:

[0009] S1. Obtaining the source code library of the embedded operating system based on the debugging hardware memory;

[0010] S2. Based on the source code library of the embedded operating system, mark all program call relationships in the source code library and establish a program running path map;

[0011] S3, actively verify according to the functional interface of the debugging hardware, and record the program running performance call data under the program running path of each interface in the program running path map;

[0012] S4. Based on the program running performance call data under the program running path, the hot program running processes in the program running performance call data are screened out and recorded as the core nodes of the program running processes to be debugged;

[0013] S5. Generate an optimization strategy based on the core node performance call execution requirements of the running process of the program to be debugged, and calculate the benefit score of each optimization strategy;

[0014] S6. Filter out the maximum benefit score of the optimization strategy as the optimization strategy for the core node of the running process of the program to be debugged.

[0015] The present invention also provides a device for debugging an embedded operating system, the device comprising: a processor and a computer-readable storage medium, the computer-readable storage medium storing a computer program, and the computer program implements the method for debugging an embedded operating system when executed by the processor.

[0016] (III) Beneficial effects

[0017] The present invention proposes a method and device for debugging an embedded operating system, which constructs a program running path map to clarify the program call relationship, uses the debugging hardware function interface to actively verify and record the program running performance data of each interface, identifies the hot program running process, generates multiple optimization strategies, and calculates the score of each strategy, and finally selects the optimization strategy with the highest score for implementation. The beneficial effect of the present invention is that it can accurately locate the system performance bottleneck, and select the optimal optimization solution through evaluation, thereby effectively improving the operating efficiency and stability of the embedded operating system. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] Figure 1 A flow chart of a method for debugging an embedded operating system according to the present invention;

[0019] Figure 2 A flowchart of a method for screening out core nodes of the running process of a program to be debugged;

[0020] Figure 3 A method flow chart for predicting the performance value of the parent-child function of the running path of the functional interface program;

[0021] Figure 4 A flow chart of the method for calculating the benefit score of each optimization strategy;

[0022] Figure 5 It is a schematic diagram of the structure of a computer-readable storage device of the present invention. DETAILED DESCRIPTION

[0023] In order to make the purpose, content and advantages of the present invention more clear, the specific implementation methods of the present invention are further described in detail below in conjunction with the drawings and examples.

[0024] In order to solve the above technical problems, a method and device for debugging an embedded operating system are provided. The technical solution solves the above-mentioned current conventional ideas that all detect by setting breakpoints on the internal execution code of the embedded system, but because the manual detection process is time-consuming and labor-intensive and it is very easy to ignore logical errors in the program, the carrier of the embedded system has no abnormalities during the initial use, but as time goes by, the stability of the carrier decreases and crashes, and there is no standard solution to the identified problems, so that the debugged carrier of the embedded system is affected by human experience and has inconsistent quality.

[0025] The present invention discloses a method and device for debugging an embedded operating system, which relates to the technical field of software design, including: based on the source code library of the embedded operating system, marking all program call relationships in the source code library, and establishing a program running path map; actively verifying according to the functional interface of the debugging hardware, recording the program running performance call data under the program running path of each interface in the program running path map; screening out the hot program running processes in the program running performance call data, and recording them as the core nodes of the program running process to be debugged; generating optimization strategies according to the performance call execution requirements of the core nodes of the program running process to be debugged, and calculating the benefit score of each optimization strategy; screening out the maximum benefit score of the optimization strategy as the optimization strategy of the core node of the program running process to be debugged. The advantages of the present invention are: effectively improving the operating efficiency and stability of the embedded operating system

[0026] In order to achieve the above purpose, the technical solution adopted by the present invention is:

[0027] A method for debugging an embedded operating system, comprising:

[0028] S1. Obtaining the source code library of the embedded operating system based on the debugging hardware memory;

[0029] S2. Based on the source code library of the embedded operating system, mark all program call relationships in the source code library and establish a program running path map;

[0030] S3, actively verify according to the functional interface of the debugging hardware, and record the program running performance call data under the program running path of each interface in the program running path map;

[0031] S4. Based on the program running performance call data under the program running path, the hot program running processes in the program running performance call data are screened out and recorded as the core nodes of the program running processes to be debugged;

[0032] S5. Generate an optimization strategy based on the core node performance call execution requirements of the running process of the program to be debugged, and calculate the benefit score of each optimization strategy;

[0033] S6. Filter out the maximum benefit score of the optimization strategy as the optimization strategy for the core node of the running process of the program to be debugged.

[0034] Preferably, based on the program running performance call data under the program running path, the hot program running processes in the program running performance call data are screened out and recorded as the core nodes of the program running processes to be debugged, specifically including:

[0035] S41, determining a performance bottleneck threshold of the embedded operating system based on the initialization performance of the embedded operating system; the initialization performance of the embedded operating system includes: CPU usage, memory usage, I / O waiting time, function call times and process execution time;

[0036] S42, based on the program running performance call data under the program running path, according to the program running path map, each functional interface is associated and mapped with the performance call chain of the parent function referencing the child function under the program running path, and the program running path parent-child function performance call matrix of the functional interface is established;

[0037]

[0038] Among them, A is the parent-child function performance call matrix of the program running path of the functional interface, x ij The performance value call value of the jth program running path parent-child function of the i-th function interface, m is the total number of function interfaces, and n is the total number of program running path parent-child functions;

[0039] S43, according to the demand direction of each element in the parent-child function performance call matrix of the program running path of the functional interface for the initialization performance of the embedded operating system, trend verification is performed according to the time dimension to obtain the parent-child function performance call trend matrix of the program running path of the functional interface;

[0040]

[0041] Among them, B is the performance call trend matrix of the parent-child function of the program running path of the functional interface, x i t j The performance value call value of the parent-child function of the jth program running path of the ith functional interface under the tth unit time;

[0042] S44, based on the performance call trend parameters of the parent-child functions of the program running path of the functional interface, training the program running performance call development trend analysis model, and predicting the performance value call values ​​of the parent-child functions of the program running path of the functional interface under unit time;

[0043] S45, judging whether the performance value call value of the parent-child function of the function interface program running path under the predicted unit time is within the performance bottleneck threshold of the embedded operating system, if not, no output is made, if so, it is recorded as the core node of the running process of the program to be debugged.

[0044] Preferably, the program running path parent-child function performance call trend parameters based on the functional interface, training the program running performance call development trend analysis model, and predicting the function interface program running path parent-child function performance value call value per unit time specifically include:

[0045] S441, calculating the performance call trend parameter deviation of the parent-child function of the program running path of each neighbor function interface according to the forward index of the unit time, and recording it as the performance call deviation characteristic parameter of the parent-child function of the program running path of the function interface;

[0046] S442. Based on AR autoregression, build an embedded system performance call trend load analysis model;

[0047] S443, taking the loss function between the actual value and the predicted value of the program running path parent-child function performance call of the minimized functional interface as the objective function;

[0048] S444, substituting the characteristic parameters of the performance call deviation of the parent-child function of the program running path of the forward index function interface per unit time into the embedded system performance call trend load analysis model to predict the performance call value of the parent-child function of the program running path of the function interface per unit time as output;

[0049] The construction of the embedded system performance call trend load analysis model is specifically as follows:

[0050]

[0051] In the formula, The predicted value of the parent-child function performance value call for the j-th program running path of the i-th functional interface under the t-th unit time, is the performance value of the parent-child function of the jth program running path of the ith functional interface under the tkth unit time, the step size of the k autoregressive lag order, p is the total number of autoregressive lag orders, ∈ t is the error term per unit time, φ1, φ2, φ k ,φ p are all autoregression coefficients.

[0052] Preferably, generating an optimization strategy based on the core node performance call execution requirement of the running process of the program to be debugged, and calculating the benefit score of each optimization strategy specifically include:

[0053] S51, based on the direction of the core node of the running process of the program to be debugged jumping out of the performance bottleneck threshold of the embedded operating system, determining the characteristic parameters of the factors affecting the core node of the running process of the program to be debugged; the characteristic parameters of the factors affecting the running process of the program to be debugged include: hot function, high latency, and resource contention;

[0054] S52, calculating the correlation coefficient between the program running path parent-child function performance call prediction value of the function interface under the unit time of the core node of the program running process to be debugged and the characteristic parameters of the factors affecting the core node of the program running process to be debugged, and determining several optimization strategies;

[0055] S53, based on a plurality of optimization strategies, analyzing the benefit score of each optimization strategy for the core node of the running process of the program to be debugged;

[0056] Wherein, the correlation coefficient is specifically:

[0057]

[0058] Where G is the correlation coefficient between the core node of the running process of the program to be debugged and the characteristics of the factors affecting the running process of the program to be debugged, y i' is the performance call prediction value of the core node of the i'th program to be debugged running process, is the average value of the predicted value, u i' is the performance call observation value under the factor characteristic parameters that affect the core node of the running process of the i'th program to be debugged, is the average value of the observed value, n' is the total number of core nodes of the running process of the program to be debugged;

[0059] The benefit score is specifically:

[0060]

[0061] Where D j' is the benefit score of the j'th optimization strategy, E j' is the performance improvement score of the j'th optimization strategy, F j' is the resource consumption reduction score of the j'th optimization strategy, α and γ are the performance optimization coefficient and resource optimization coefficient respectively.

[0062] Embodiment 1:

[0063] The following description is used to disclose the present invention so that those skilled in the art can implement the present invention. The preferred embodiments described below are only examples, and those skilled in the art may think of other obvious variations.

[0064] Reference Figure 1 As shown, a method for debugging an embedded operating system includes:

[0065] Based on the debugging hardware memory, obtain the source code library of the embedded operating system;

[0066] Based on the source code library of the embedded operating system, mark all program call relationships in the source code library and establish a program running path map;

[0067] Actively verify according to the functional interface of the debugging hardware, and record the program running performance call data under the program running path of each interface in the program running path map;

[0068] Based on the program running performance call data under the program running path, the hot program running processes in the program running performance call data are screened out and recorded as the core nodes of the program running processes to be debugged;

[0069] Generate optimization strategies based on the core node performance call execution requirements of the program to be debugged, and calculate the benefit score of each optimization strategy;

[0070] The maximum benefit score of the optimization strategy is selected as the optimization strategy for the core node of the running process of the program to be debugged.

[0071] This solution constructs a program running path map to clarify the program call relationship, uses the debugging hardware function interface to actively verify and record the program running performance data of each interface, identifies the hot program running process, generates multiple optimization strategies, and calculates the score of each strategy, and finally selects the optimization strategy with the highest score for implementation. The beneficial effect of the present invention is that it can accurately locate the system performance bottleneck, and select the optimal solution through evaluation, thereby effectively improving the operating efficiency and stability of the embedded operating system.

[0072] Reference Figure 2 As shown, based on the program running performance call data under the program running path, the hot program running processes in the program running performance call data are screened out, and the core nodes of the program running process to be debugged specifically include:

[0073] Determine the performance bottleneck threshold of the embedded operating system based on the initialization performance of the embedded operating system; the initialization performance of the embedded operating system includes: CPU usage, memory usage, I / O waiting time, function call times, and process execution time;

[0074] Based on the program running performance call data under the program running path, according to the program running path map, each functional interface is associated and mapped with the performance call chain of the parent function referencing the child function under the program running path, and the program running path parent-child function performance call matrix of the functional interface is established;

[0075]

[0076] Among them, A is the parent-child function performance call matrix of the program running path of the functional interface, x ij The performance value call value of the jth program running path parent-child function of the i-th function interface, m is the total number of function interfaces, and n is the total number of program running path parent-child functions;

[0077] According to the demand direction of each element in the parent-child function performance call matrix of the program running path of the functional interface for the initialization performance of the embedded operating system, trend verification is performed according to the time dimension to obtain the parent-child function performance call trend matrix of the program running path of the functional interface;

[0078]

[0079] Among them, B is the performance call trend matrix of the parent-child function of the program running path of the functional interface, The performance value call value of the parent-child function of the jth program running path of the ith functional interface under the tth unit time;

[0080] Based on the performance call trend parameters of the parent-child functions of the program running path of the functional interface, the program running performance call development trend analysis model is trained to predict the performance value call values ​​of the parent-child functions of the program running path of the functional interface per unit time;

[0081] Determine whether the performance value call value of the parent-child function of the function interface program running path under the predicted unit time is within the performance bottleneck threshold of the embedded operating system. If not, no output is made. If so, it is recorded as the core node of the running process of the program to be debugged.

[0082] It is understandable that due to high load or long-term operation, the embedded system accumulates a lot of resource consumption or errors in the code, but due to sufficient performance resources in the early stage, as time goes by and conditions change, the hardware carrier of the embedded system collapses.

[0083] Reference Figure 3 As shown, the program running path parent-child function performance call trend parameters based on the functional interface, the training program running performance call development trend analysis model, and the prediction of the functional interface program running path parent-child function performance value call value per unit time specifically include:

[0084] The program running path parent-child function performance call trend parameter deviation of each neighbor function interface is calculated according to the forward index of the unit time, and recorded as the program running path parent-child function performance call deviation characteristic parameter of the function interface;

[0085] Based on AR autoregression, a performance call trend load analysis model for embedded systems is constructed;

[0086] The objective function is to minimize the loss function between the actual value and the predicted value of the parent-child function performance call of the program running path of the functional interface;

[0087] Substitute the performance call deviation characteristic parameters of the parent-child function of the program running path of the forward index function interface per unit time into the embedded system performance call trend load analysis model to predict the performance call value of the parent-child function of the program running path of the function interface per unit time as the output;

[0088] The construction of the embedded system performance call trend load analysis model is specifically as follows:

[0089]

[0090] In the formula, The predicted value of the parent-child function performance value call for the j-th program running path of the i-th functional interface under the t-th unit time, is the performance value of the parent-child function of the jth program running path of the ith functional interface under the tkth unit time, the step size of the kth autoregressive lag order, P is the total number of autoregressive lag orders, ∈ t is the error term per unit time, φ1, φ2, φ k ,φ p are all autoregression coefficients.

[0091] It can be understood that, since the carrier performance of the embedded system is usually limited, the embedded system performance call trend load analysis model in this solution is deployed in an external device to debug the embedded system carrier to be debugged.

[0092] Reference Figure 4 As shown in FIG. 1 , the optimization strategy is generated according to the core node performance call execution demand of the running process of the program to be debugged, and the benefit score of each optimization strategy is calculated, which specifically includes:

[0093] Based on the direction in which the core node of the running process of the program to be debugged jumps out of the performance bottleneck threshold of the embedded operating system, determining the characteristic parameters of the factors affecting the core node of the running process of the program to be debugged; the characteristic parameters of the factors affecting the running process of the program to be debugged include: hot function, high latency, and resource contention;

[0094] Calculate the correlation coefficient between the program running path parent-child function performance call prediction value of the function interface under the unit time of the core node of the program running process to be debugged and the characteristic parameters of the factors affecting the core node of the program running process to be debugged, and determine several optimization strategies;

[0095] Based on several optimization strategies, analyze the benefit score of each optimization strategy for the core nodes of the running process of the program to be debugged;

[0096] Wherein, the correlation coefficient is specifically:

[0097]

[0098] Where G is the correlation coefficient between the core node of the running process of the program to be debugged and the characteristics of the factors affecting the running process of the program to be debugged, y i' is the performance call prediction value of the core node of the i'th program to be debugged, u i' is the performance call observation value under the factor characteristic parameters affecting the core node of the running process of the i'th program to be debugged, and n' is the total number of core nodes of the running process of the program to be debugged.

[0099] The benefit score is specifically:

[0100]

[0101] Where D j' is the benefit score of the j'th optimization strategy, E j' is the performance improvement score of the j'th optimization strategy, F j' is the resource consumption reduction score of the j'th optimization strategy, α and γ are the performance optimization coefficient and resource optimization coefficient respectively.

[0102] It can be understood that the greater the correlation coefficient, the greater the impact on the core node of the program to be debugged running process jumping out of the performance bottleneck threshold of the embedded operating system, and the smaller the correlation coefficient, the smaller the impact on the core node of the program to be debugged running process jumping out of the performance bottleneck threshold of the embedded operating system;

[0103] Embodiment 2:

[0104] Figure 5 is a schematic diagram of a device structure for debugging an embedded operating system provided by an embodiment of the present application. The device for debugging an embedded operating system includes: a processor and a computer-readable storage medium, such as Figure 5As shown, a computer-readable storage medium 600 according to an embodiment of the present application is shown. Computer-readable instructions are stored on the computer-readable storage medium 600. When the computer-readable instructions are executed by the processor, a method for debugging an embedded operating system according to an embodiment of the present application described with reference to the above figures can be executed. The storage medium 600 includes, but is not limited to, for example, volatile memory and / or non-volatile memory. Volatile memory may include, for example, random access memory (RAM) and cache memory (cache), etc. Non-volatile memory may include, for example, read-only memory (ROM), hard disk, flash memory, etc.

[0105] Compared with the prior art, the present invention has the following beneficial effects:

[0106] The present invention proposes a scheme for debugging an embedded operating system, which constructs a program running path map to clarify the program call relationship, uses the debugging hardware function interface to actively verify and record the program running performance data of each interface, identifies the hot program running process, generates multiple optimization strategies, and calculates the score of each strategy, and finally selects the optimization strategy with the highest score for implementation. The beneficial effect of the present invention is that it can accurately locate the system performance bottleneck, select the optimal optimization solution through evaluation, thereby effectively improving the operating efficiency and stability of the embedded operating system.

[0107] The above is only a preferred embodiment of the present invention. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the technical principles of the present invention. These improvements and modifications should also be regarded as the scope of protection of the present invention.

Claims

1. A method for debugging an embedded operating system, characterized in that: The method comprises the following steps: S1. Obtaining the source code library of the embedded operating system based on the debugging hardware memory; S2. Based on the source code library of the embedded operating system, mark all program call relationships in the source code library and establish a program running path map; S3, actively verify according to the functional interface of the debugging hardware, and record the program running performance call data under the program running path of each interface in the program running path map; S4. Based on the program running performance call data under the program running path, the hot program running processes in the program running performance call data are screened out and recorded as the core nodes of the program running processes to be debugged; S5. Generate an optimization strategy based on the core node performance call execution requirements of the running process of the program to be debugged, and calculate the benefit score of each optimization strategy; S6. Filter out the maximum benefit score of the optimization strategy as the optimization strategy for the core node of the running process of the program to be debugged.

2. The method for debugging an embedded operating system according to claim 1, wherein: The step S4 specifically includes: S41, determining a performance bottleneck threshold of the embedded operating system based on the initialization performance of the embedded operating system; the initialization performance of the embedded operating system includes: CPU usage, memory usage, I / O waiting time, function call times and process execution time; S42, based on the program running performance call data under the program running path, according to the program running path map, each functional interface is associated and mapped with the performance call chain of the parent function referencing the child function under the program running path, and the program running path parent-child function performance call matrix of the functional interface is established; S43, according to the demand direction of each element in the parent-child function performance call matrix of the program running path of the functional interface for the initialization performance of the embedded operating system, trend verification is performed according to the time dimension to obtain the parent-child function performance call trend matrix of the program running path of the functional interface; S44, based on the performance call trend parameters of the parent-child functions of the program running path of the functional interface, training the program running performance call development trend analysis model, and predicting the performance value call values ​​of the parent-child functions of the program running path of the functional interface under unit time; S45, judging whether the performance value call value of the parent-child function of the function interface program running path under the predicted unit time is within the performance bottleneck threshold of the embedded operating system, if not, no output is made, if so, it is recorded as the core node of the running process of the program to be debugged.

3. The method for debugging an embedded operating system according to claim 2, wherein: In S42, the parent-child function performance call matrix of the program running path of the functional interface is: Among them, A is the parent-child function performance call matrix of the program running path of the functional interface, x ij The performance value call value of the j-th program execution path parent-child function of the ith functional interface, m is the total number of functional interfaces, and n is the total number of program execution path parent-child functions.

4. The method for debugging an embedded operating system as claimed in claim 3, characterized in that: In S43, the program running path parent-child function performance call trend matrix of the functional interface is: Among them, B is the program running path parent-child function performance call trend matrix of the functional interface, It is the performance value call value of the parent-child function of the j-th program running path of the ith functional interface under the t-th unit time.

5. The method for debugging an embedded operating system according to claim 4, characterized in that: The S44 specifically includes: S441, calculating the performance call trend parameter deviation of the parent-child function of the program running path of each neighbor function interface according to the forward index of the unit time, and recording it as the performance call deviation characteristic parameter of the parent-child function of the program running path of the function interface; S442. Based on AR autoregression, build an embedded system performance call trend load analysis model; S443, taking the loss function between the actual value and the predicted value of the program running path parent-child function performance call of the minimized functional interface as the objective function; S444. Substitute the performance call deviation characteristic parameters of the parent-child function of the program running path of the forward index function interface per unit time into the embedded system performance call trend load analysis model to predict the performance call value of the parent-child function of the program running path of the function interface per unit time as output.

6. The method for debugging an embedded operating system according to claim 5, characterized in that: In S442, the construction of the embedded system performance call trend load analysis model is specifically as follows: In the formula, The predicted value of the parent-child function performance value call for the j-th program running path of the i-th functional interface under the t-th unit time, is the performance value of the parent-child function of the jth program running path of the ith functional interface under the tkth unit time, the step size of the k autoregressive lag order, p is the total number of autoregressive lag orders, ∈ t is the error term per unit time, φ1, φ2, φ k ,φ p are all autoregressive coefficients.

7. The method for debugging an embedded operating system according to any one of claims 1 to 6, characterized in that: The S5 specifically includes: S51, based on the direction in which the core node of the running process of the program to be debugged jumps out of the performance bottleneck threshold of the embedded operating system, determining the characteristic parameters of the factors affecting the core node of the running process of the program to be debugged; the characteristic parameters of the factors affecting the running process of the program to be debugged include: hot function, high latency and resource contention; S52, calculating the correlation coefficient between the program running path parent-child function performance call prediction value of the function interface under the unit time of the core node of the program running process to be debugged and the characteristic parameters of the factors affecting the core node of the program running process to be debugged, and determining several optimization strategies; S53. Based on a plurality of optimization strategies, analyze the benefit score of each optimization strategy for the core node of the running process of the program to be debugged.

8. The method for debugging an embedded operating system according to claim 7, wherein: In S52, the correlation coefficient is specifically: Where G is the correlation coefficient between the core node of the running process of the program to be debugged and the characteristics of the factors affecting the running process of the program to be debugged, y i' is the performance call prediction value of the core node of the i'th program to be debugged running process, is the average value of the predicted value, u i' is the performance call observation value under the factor characteristic parameters that affect the core node of the running process of the i'th program to be debugged, is the average value of the observed value, and n' is the total number of core nodes of the running process of the program to be debugged.

9. The method for debugging an embedded operating system according to claim 7, wherein: In S53, the benefit score is specifically: Where D j' is the benefit score of the j'th optimization strategy, E j' is the performance improvement score of the j'th optimization strategy, F j' is the resource consumption reduction score of the j'th optimization strategy, α and γ are the performance optimization coefficient and resource optimization coefficient respectively.

10. A device for debugging an embedded operating system, the device comprising: A processor and a computer-readable storage medium, wherein the computer-readable storage medium stores a computer program, wherein when the computer program is executed by the processor, the method for debugging an embedded operating system according to any one of claims 1 to 9 is implemented.

Images