A method and device for debugging an embedded operating system

Abstract

The present invention relates to a method and device for debugging an embedded operating system, and belongs to the field of software technology. The present invention is based on the source code library of the embedded operating system, marks all program call relationships in the source code library, and establishes a program running path map; actively verifies according to the functional interface of the debugging hardware, records the program running performance call data under the program running path of each interface in the program running path map; filters out the hot program running processes in the program running performance call data, and records them as the core nodes of the program running process to be debugged; generates an optimization strategy based on the performance call execution requirements of the core nodes of the program running process to be debugged, and calculates the benefit score of each optimization strategy; filters 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.

Description

Technical Field

[0001] The present 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] An embedded operating system (EOS) is an operating system specifically designed for embedded systems. Embedded systems typically refer to non-desktop computer systems—that is, not PCs, servers, or minicomputers. Instead, these systems are computer devices or equipment that possess computer functionality and can be "embedded" into dedicated equipment to perform specialized functions.

[0003] Currently, the conventional approach is to set breakpoints in the internal execution code of the embedded system for detection. However, since the manual detection process is time-consuming and labor-intensive and it is very easy to overlook logical errors in the program, the carrier of the embedded system may be normal during initial use, but over time the carrier's stability decreases and it may crash. There is no standard solution to the identified problems, so the debugged embedded system carrier is affected by human experience and the quality varies. 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 since the manual detection process is time-consuming and labor-intensive and it is very easy to overlook logical errors in the program, the carrier of the embedded system has no abnormalities during initial use, but as time goes by, the stability of the carrier decreases and it 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 the quality is inconsistent.

[0006] (2) 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 the functional interface of the debugging hardware and record the program execution performance call data under the program execution path of each interface in the program execution path map;

[0012] S4. Based on the program execution performance call data under the program execution path, filter out the hot program execution processes in the program execution performance call data and record them as the core nodes of the program execution processes to be debugged;

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

[0014] S6. Filter out the optimization strategy with the maximum benefit score 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, which includes: a processor and a computer-readable storage medium. The computer-readable storage medium stores a computer program. When the computer program is executed by the processor, the method for debugging the embedded operating system is implemented.

[0016] (3) Beneficial effects

[0017] The present invention proposes a method and apparatus for debugging an embedded operating system. This method constructs a program execution path map to clarify program call relationships, utilizes debugging hardware function interfaces to proactively verify and record program execution performance data for each interface, identifies hotspot program execution processes, generates multiple optimization strategies, calculates a score for each strategy, and ultimately selects the optimization strategy with the highest score for implementation. The present invention has the beneficial effect of accurately locating system performance bottlenecks and, through evaluation and selection of the optimal optimization solution, 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 the program to be debugged;

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

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

[0022] Figure 5 Schematic diagram of the computer-readable storage device structure 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 with reference to the accompanying drawings and examples.

[0024] In order to solve the above technical problems, a method and device for debugging an embedded operating system are provided. This technical solution solves the above-mentioned current conventional ideas, which are to set breakpoints on the internal execution code of the embedded system for detection. However, since 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. In addition, there is no standard solution to the identified problems, which makes the debugged carrier of the embedded system affected by human experience and the quality is inconsistent.

[0025] The present invention discloses a method and device for debugging an embedded operating system, which relates to the field of software design technology, 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 an optimization strategy based on 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 objects, 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 the functional interface of the debugging hardware and record the program execution performance call data under the program execution path of each interface in the program execution path map;

[0031] S4. Based on the program execution performance call data under the program execution path, filter out the hot program execution processes in the program execution performance call data and record them as the core nodes of the program execution processes to be debugged;

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

[0033] S6. Filter out the optimization strategy with the maximum benefit score 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 process to be debugged, specifically including:

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

[0036] S42. Based on the program execution performance call data under the program execution path, and according to the program execution path map, each functional interface is associated and mapped with a performance call chain of a parent function referencing a child function under the program execution path, thereby establishing a program execution path parent-child function performance call matrix of the functional interface.

[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 execution path parent-child function of the i-th functional interface, m is the total number of functional interfaces, and n is the total number of program execution path parent-child functions;

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

[0040]

[0041] Among them, B is the parent-child function performance call trend matrix 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 j-th program running path of the i-th functional interface under the t-th unit time;

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

[0043] S45. 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, do not output. If so, record it as the core node of the running process of the program to be debugged.

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

[0045] S441. Calculate the performance call trend parameter deviation of the parent-child function of the program execution path of each neighboring functional interface according to the forward index per unit time, and record it as the performance call deviation characteristic parameter of the parent-child function of the program execution path of the functional interface;

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

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

[0048] S444: Substitute the characteristic parameters of the performance call deviation of the parent-child function of the program execution 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 execution 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] Where, The predicted value of the parent-child function performance value of the j-th program execution path of the i-th functional interface under the t-th unit time is called. is the performance value of the parent-child function of the jth program execution 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.

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

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

[0054] S52, calculating the correlation coefficient between the predicted value of the program execution path parent-child function call performance of the functional interface per unit time of the core node of the program to be debugged running process and the characteristic parameters of the factors affecting the core node of the program to be debugged running process, 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 program to be debugged and the characteristics of the factors affecting the program to be debugged, and 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 affecting 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] Example 1:

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

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

[0065] Obtain the source code library of the embedded operating system based on the debugging hardware memory;

[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 the functional interface of the debugging hardware and record the program execution performance call data under the program execution path of each interface in the program execution 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 performance call execution requirements of the core nodes of the program to be debugged, and calculate the benefit score of each optimization strategy;

[0070] The optimization strategy with the maximum benefit score 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 execution path map to clarify program call relationships, utilizes debugging hardware function interfaces to proactively verify and record program execution performance data for each interface, identifies hot program execution processes, generates multiple optimization strategies, calculates a score for each strategy, and ultimately selects the optimization strategy with the highest score for implementation. The beneficial effects of this invention are: it can accurately locate system performance bottlenecks and select the optimal optimization 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 recorded as the core nodes of the program running process to be debugged, specifically including:

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

[0074] Based on the program execution performance call data under the program execution path, each functional interface is associated and mapped with the performance call chain of the parent function referencing the child function under the program execution path according to the program execution path map, and a program execution 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 execution path parent-child function of the i-th functional interface, m is the total number of functional interfaces, and n is the total number of program execution 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 parent-child function performance call trend matrix of the program running path of the functional interface, The performance value call value of the parent-child function of the j-th program running path of the i-th functional interface under the t-th 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 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 large amount of resource consumption or errors in the code. However, 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 execution path parent-child function performance call trend parameters based on the functional interface, the training program execution performance call development trend analysis model, and the prediction of the functional interface program execution path parent-child function performance value call value per unit time specifically include:

[0084] Calculate 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 record it as the performance call deviation characteristic parameter of the parent-child function of the program running path 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 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 the output;

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

[0089]

[0090] Where, The predicted value of the parent-child function performance value of the j-th program execution path of the i-th functional interface under the t-th unit time is called. The performance value of the parent-child function of the jth program execution path of the i-th functional interface under the tk-th unit time is called the deviation value, the step size of the k-th 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.

[0091] It can be understood that, since the carrier performance of embedded systems 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 the figure, the optimization strategy is generated based on the core node performance call execution requirements of the program to be debugged, and the benefit score of each optimization strategy is calculated, which specifically includes:

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

[0094] Calculate the correlation coefficient between the predicted value of the parent-child function performance call of the program running path of the function interface per 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 program running process to be debugged;

[0096] Wherein, the correlation coefficient is specifically:

[0097]

[0098] Where G is the correlation coefficient between the core node of the program to be debugged and the characteristics of the factors affecting the program to be debugged, and 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 process of the program to be debugged, and n' is the total number of core nodes of the 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] Example 2:

[0104] Figure 5 Schematic diagram of a device for debugging an embedded operating system according to an embodiment of the present invention. The device for debugging an embedded operating system includes: a processor and a computer-readable storage medium, such as Figure 5, a computer-readable storage medium 600 according to one 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 a 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, volatile memory and / or non-volatile memory. Volatile memory may include, for example, random access memory (RAM) and cache memory. Non-volatile memory may include, for example, read-only memory (ROM), a hard disk, flash memory, etc.

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

[0106] This paper proposes a solution for debugging an embedded operating system. This solution constructs a program execution path map to clarify program call relationships, utilizes debugging hardware function interfaces to proactively verify and record program execution performance data for each interface, identifies hotspot program execution processes, generates multiple optimization strategies, calculates a score for each strategy, and ultimately selects the optimization strategy with the highest score for implementation. The present invention has the beneficial effect of accurately locating system performance bottlenecks and, through evaluation and selection of the optimal optimization solution, 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 the functional interface of the debugging hardware and record the program execution performance call data under the program execution path of each interface in the program execution path map; S4. Based on the program execution performance call data under the program execution path, filter out the hot program execution processes in the program execution performance call data and record them as the core nodes of the program execution processes to be debugged; S5. Generate an optimization strategy based on the performance call execution requirements of the core node of the running process of the program to be debugged, and calculate the benefit score of each optimization strategy; S6. Filter out the optimization strategy with the maximum benefit score as the optimization strategy for the core node of the running process of the program to be debugged; in, The step S4 specifically includes: S41. Determine a performance bottleneck threshold of the embedded operating system based on initialization performance of the embedded operating system; the initialization performance of the embedded operating system includes: CPU usage, memory usage, I / O wait time, number of function calls, and process execution time; S42. Based on the program execution performance call data under the program execution path, and according to the program execution path map, each functional interface is associated and mapped with a performance call chain of a parent function referencing a child function under the program execution path, thereby establishing a program execution path parent-child function performance call matrix of the functional interface. S43. Based on the demand direction of each element in the parent-child function performance call matrix of the program execution path of the functional interface for the initialization performance of the embedded operating system, trend verification is performed along the time dimension to obtain the parent-child function performance call trend matrix of the program execution path of the functional interface; S44, based on the performance call trend parameters of the parent-child functions of the program execution path of the functional interface, training the program execution performance call development trend analysis model, and predicting the performance call values of the parent-child functions of the program execution path of the functional interface under unit time; S45. 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, do not output. If so, record it as 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: In S42, the parent-child function performance call matrix of the program execution 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 jth program execution path parent-child function of the i-th functional interface, m is the total number of functional interfaces, and n is the total number of program execution path parent-child functions.

3. The method for debugging an embedded operating system according to claim 2, wherein: In S43, the program execution path parent-child function performance call trend matrix of the functional interface is: Among them, B is the parent-child function performance call trend matrix of the program running path 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 i-th functional interface under the t-th unit time.

4. The method for debugging an embedded operating system according to claim 3, wherein: The S44 specifically includes: S441. Calculate the performance call trend parameter deviation of the parent-child function of the program execution path of each neighboring functional interface according to the forward index per unit time, and record it as the performance call deviation characteristic parameter of the parent-child function of the program execution path of the functional interface; S442. Based on AR autoregression, build an embedded system performance call trend load analysis model; S443, using the loss function between the actual value and the predicted value of the program execution 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 the output.

5. The method for debugging an embedded operating system according to claim 4, wherein: In S442, the construction of the embedded system performance call trend load analysis model is specifically as follows: Where, The predicted value of the parent-child function performance value of the j-th program execution path of the i-th functional interface under the t-th unit time is called. is the performance value of the parent-child function of the jth program execution 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.

6. The method for debugging an embedded operating system according to any one of claims 1 to 5, wherein: The S5 specifically includes: S51, determining characteristic parameters of factors affecting the core node of the program to be debugged running process based on the direction in which the core node of the program to be debugged running process has jumped out of the performance bottleneck threshold of the embedded operating system; the characteristic parameters of factors affecting the program to be debugged running process include: hot function, high latency and resource contention; S52, calculating the correlation coefficient between the predicted value of the program execution path parent-child function call performance of the functional interface per unit time of the core node of the program to be debugged running process and the characteristic parameters of the factors affecting the core node of the program to be debugged running process, 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.

7. The method for debugging an embedded operating system according to claim 6, wherein: In the S52, the correlation coefficient is specifically: Where G is the correlation coefficient between the core node of the program to be debugged and the characteristics of the factors affecting the program to be debugged, and 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 affecting 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.

8. The method for debugging an embedded operating system according to claim 6, 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.

9. 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 8 is implemented.

Images