CN116302945A - Test method for measuring real-time performance of Linux system - Google Patents

Abstract

The invention discloses a test method for measuring real-time performance of a Linux system, which relates to the technical field of computers and comprises a plurality of steps of firstly importing source codes into the Linux system to generate a Linux kernel module and executable files, then inserting the kernel module into the Linux kernel to collect and store kernel information, then testing classified fine-granularity test points through the kernel module, testing coarse-granularity test points in a user mode, reacting the obtained delay data of the demand points in the kernel to the user mode, and carrying out calculation and arrangement through the kernel module and a coarse-granularity simulation process to output real-time performance data of the reaction Linux system. According to the method, the Linux kernel mode and the user mode are cooperated to perform rich simulation test, corresponding real-time related quantized data are obtained, and the test result is more comprehensive and accurate.

Description

A Test Method for Measuring the Real-time Performance of Linux System

technical field

The invention belongs to the technical field of computers, and in particular relates to a test method for measuring the real-time performance of a Linux system.

Background technique

As a leader in open source systems, the Linux system has a wide range of application scenarios. The origin of the Linux system is a user-interactive system, and there is no real-time consideration. However, as the open source Linux system becomes more and more popular, the Linux system has obtained a real-time optimized kernel patch, so that the Linux system kernel can become As a real-time system kernel, the Linux system improves its real-time performance by patching the Linux kernel to meet the real-time requirements of most scenarios. The real-time performance of the operating system is a relatively abstract concept. It can be understood as completing the specified work within a specified time. It can be called that the operating system has reached a certain level of real-time performance. It is easily affected by the mutual influence of hardware resources and software, etc. , To measure the real-time performance of the Linux system, it needs to be reflected by the test tools and data.

The Cyclictest tool is a more authoritative tool for measuring the real-time performance of Linux systems. It simulates the scheduling of Linux systems in user mode, and obtains the kernel interrupt delay and kernel scheduling delay by subtracting timestamps. It reflects the real-time performance of the Linux system, but the Cyclictest tool is only a tool in the real-time test tool set of Linux. The simulation process used to measure real-time performance is relatively small, and the real-time performance data reflected are relatively simple, and Cyclictest is only available in user mode. There will inevitably be a slight additional time overhead for simulation and data output.

In addition, Ftrace is a built-in module of the Linux system kernel. The real-time performance of the system can track relevant detectable points during system operation through the Ftrace tool, and pay attention to the function call process related to real-time performance, so as to achieve the purpose of quantifying real-time performance. Ftrace is officially supported by Linux. It is essentially a Linux kernel tracking mechanism module. Real-time detection is only one of its functions. Moreover, the data obtained through Ftrace is often not intuitive enough, the operation is more complicated, and the integration degree is not high enough. Further data processing is required to obtain quantitative real-time data.

Contents of the invention

Existing tools for measuring the real-time performance of Linux systems, such as Cyclictest and Ftrace, have relatively few simulation processes for measuring real-time performance, and the real-time performance data reflected are relatively simple, and there is additional time overhead and insufficient data acquisition Intuitive, complex operation, insufficient integration, and further quantitative processing of data are needed. The present invention provides a test method for measuring the real-time performance of the Linux system.

The scheme that the present invention solves its technical problem adopts is: a kind of test method that is used to measure the real-time performance of Linux system comprises the following steps:

Step 1, build special-purpose kernel module and test tool: import source code in the Linux system and compile, compile and produce a Linux kernel module and an executable file, wherein this executable file is a test tool;

Step 2, insert the kernel module in the Linux kernel: insert the kernel module in the Linux kernel, and realize the collection of kernel information according to the work content of the self-defined kernel module and save the collected information in the kernel module;

Step 3, determine the test index items and classify: distinguish the test index items according to the granularity, so that the fine-grained test points are tested to obtain data through the kernel module, and the coarse-grained test points are tested in the user mode in the Linux system;

Step 4: Execute the user mode test: the user runs the executable file compiled in the above step 1 to simulate the user mode test point, simulate a coarse-grained simulation program, and stamp time stamps before and after the simulation process, and perform time period statistics to Obtain the data of the test point;

Step 5, test in the kernel module: through the trace event set in the kernel, trigger the above event during the running of the kernel, realize the statistics of system parameters, and subtract the time stamps of different event statistics to obtain the tested requirements The delay of the point is reflected in the user state after obtaining the delayed data of the demand point in the kernel;

In step six, the kernel module combines the coarse-grained simulation process and the kernel data collected from the above steps to perform calculation and sorting, so as to output the real-time data of the Linux system that the user cares about.

As a preferred technical solution of the present invention, in the second step, the kernel module is inserted into the Linux kernel by using the insmod command.

As a preferred technical solution of the present invention, the test index items in the step 3 include interrupt response delay, semaphore operation delay, message queue operation delay, context switching delay, mutex operation delay, timer Operation Delay, Event Operation Delay, Task Operation Delay, and Scheduled Operation Delay.

As a preferred technical solution of the present invention, the criterion for distinguishing test index items in the third step is whether the encapsulation of demand points can be realized.

As a preferred technical solution of the present invention, the kernel module in the step 5 adopts tracer technology, and interacts with the kernel module through the user's input, sets and calls the corresponding function, obtains the kernel module test data required by the user, and passes the proc The file system feeds back to the user.

As a preferred technical solution of the present invention, the proc file system is a communication window between the kernel state and the user state in the Linux system, and the user observes the real-time test data through the proc file system.

As a preferred technical solution of the present invention, the process of calculating and arranging the data in the step 6 is to process a large amount of time data acquired by the cycle test, and each time the time data is obtained in a cycle, the minimum value and the minimum value of the data item are updated. The maximum value and cumulative sum, the cumulative sum is used to finally output the average value, and finally output the real-time quantitative data of the Linux system that users care about.

Compared with the prior art, the beneficial effects of the present invention are: the test method for measuring the real-time performance of the Linux system proposed by the present invention has built a dedicated kernel module, which can carry out real-time simulation tests in the kernel state, thereby reducing the loss of time , to improve the accuracy of test results; and by combining the Linux kernel state and user state, it also enriches the test index items in the existing real-time test tools, and the test environment is more specific, and by obtaining the time before and after the simulation environment, with Obtain the time of the test process that the user cares about, so that the real-time performance test of the Linux system is more comprehensive and accurate.

Description of drawings

Fig. 1 is the overall flow schematic diagram of the present invention;

Fig. 2 is a schematic diagram of the compilation process of the present invention;

Fig. 3 is a schematic diagram of the testing workflow of the present invention.

Detailed ways

The present invention will be further described below in conjunction with the accompanying drawings and embodiments.

Please refer to Fig. 1-3, the present invention provides a kind of test method for measuring the real-time performance of Linux system, combines the measurement method of Linux system kernel state and user state test data, provides richer test point, simulates more specific environment , obtain the time before and after the simulation environment to obtain the time of the test process that the user cares about, which better reflects the real-time nature of the Linux system.

Embodiment one:

The testing method for measuring the real-time performance of the Linux system provided by the present invention comprises the following steps,

Step 1, build a dedicated kernel module and testing tools: Import the source code into the Linux system with the Linux5.10rt kernel for compilation. The Linux system includes user mode and kernel mode. After compilation, a Linux kernel module and an executable file, the kernel module belongs to the kernel state, and the executable file belongs to the user state. The kernel module is used to detect the detectable points in the kernel to obtain relevant call information, and interact with the user state through the proc file system, and the executable The file is a test tool, that is, the user mode executable file not only communicates with the kernel module to obtain data, but also performs some simulation tests with large granularity to enrich the test data;

Step 2, insert the kernel module into the Linux kernel: The Linux kernel module is a file in ko format, which is divided into modules that are statically compiled into the kernel and modules that are dynamically loaded with the insmod command. The ko file is essentially an ELF file, which is different from an ordinary ELF file. Compared with the file, there is one more section structure, which is used to record some information of the ko module. This information is used when the kernel loads the module. The kernel module is inserted into the Linux kernel by using the insmod command. These dynamically inserted kernel modules have strong The flexibility allows the Linux kernel to insert the corresponding kernel module into the kernel when certain functions are needed. After the Linux kernel module is inserted into the kernel, the kernel module will start working according to the work content of the self-defined kernel module. In this method, the Based on the operation of the Linux kernel, collect kernel information. For example, in the kernel module, add time stamps to the places where the two function calls of interrupts and interrupts are called to obtain the corresponding time, and then subtract the time to obtain the corresponding time. The interrupt processing time of the interrupt, the information obtained is the delay time of each demand point in the kernel, and finally the collected information is stored in the kernel module;

Step 3: Determine and classify the test index items: distinguish the test index items according to the granularity, the test index items include interrupt response delay, semaphore operation delay, message queue operation delay, context switching delay, mutex Operation delay, timer operation delay, event operation delay, task operation delay and scheduling operation delay, the above-mentioned test index items are distinguished according to the granularity. The standard of distinction is whether the system realizes the encapsulation of the demand point, Among them, the fine-grained test points are tested to obtain data through the kernel module, and the coarse-grained test points are tested in the user state in the Linux system, that is, the above-mentioned interrupt response delay and context switching delay are tested in the kernel module, and the above-mentioned Other index items are placed in the user state for testing, so that by refining various basic behaviors of the operating system, such as interrupt processing time, context switching time, etc., the refined behavior is abstracted, and each abstracted behavior is simulated Test and obtain the corresponding time values, which can well reflect the real-time performance of the operating system;

Step 4: Execute user-mode testing: When performing user-mode testing, the user runs the executable file compiled in the above step 1. The executable file is used to carry user input to modify other adjustable data such as the number of test cycles. The executable file simulates different test schemes, obtains the data that the user cares about, simulates the test points in the user state, runs the coarse-grained simulation program of the user state simulation, and stamps the time stamps before and after the simulation process of the corresponding index items in the above step 3. Perform time period statistics, and use memory locks and real-time scheduling strategies to avoid the impact of preemption as much as possible to obtain test point data;

Step 5: Test in the kernel module: Test in the kernel module, that is, the above-mentioned interrupt response delay and context switching delay are tested in the kernel module. The kernel module uses the tracer technology to pass the trace event set in the kernel. Trigger the set event during the running of the kernel, realize the statistics of system parameters such as time, and subtract the time stamps of different event statistics to obtain the delay of the tested demand point, and obtain the delay data of the demand point in the kernel Afterwards, it responds to the user state through the proc file system, which is convenient for user interaction, that is, interacts with the kernel module through user input, sets and calls corresponding functions, obtains the test data of the kernel module required by the user, and feeds back to the user through the proc file system. The module defines a custom directory under the proc file system for user interaction. The proc file system is a communication window between the kernel state and the user state in the Linux system. It is a virtual file system and is very suitable for observing Linux systems. The kernel information is used as the communication channel between the kernel mode and the user mode, and the contents in the proc file system are dynamically created.

In this method, by defining a part of the file for user input, the input content can be copied from the user state to the kernel state through the system interface for use; the same part of the file is used for the observation of real-time test data, and the data in it is from the kernel In addition, the kernel module also adopts the mechanism of tracepoint. The tracepoint is reserved in some fixed positions in the kernel where the code can be inserted. The code that can be inserted here is mainly to count the data of the corresponding time stamp and perform Save, subtract the saved time stamp data in the kernel module, obtain the delay time value of the test demand point, reflect it from the kernel state to the user state through the proc file system, and call the user state code to the interface of the proc file system, you can It is not necessary to obtain the data in the proc file system through the terminal, so that the kernel module can communicate with the user state. The present invention obtains the timestamp of the system as accurately as possible before and after the test process, and reduces the interference of the system to the process. The test method of the kernel can reduce the time overhead caused by the switching of the nuclear state, so that the test results are more accurate.

Step 6. The kernel module combines the coarse-grained simulation process and the kernel data collected from the above steps to perform calculation and sorting, that is, to process the time data obtained by a large number of loop tests, and to update the time data acquired each cycle. The minimum value, maximum value, and cumulative sum of the data items are subtracted from the timestamp, and the cumulative sum is used to output the average value at the end, and finally output the real-time quantitative data of the Linux system that users care about. The test method for measuring the real-time performance of the Linux system proposed by the present invention adopts a relatively short process of operating system operation to summarize an abstract description of the real-time performance of the system, and then judges the real-time performance of the system with the abstract description and test data. Combining the advantages of obtaining Linux data from the kernel state and the convenience of user state test tools, it enriches the Linux real-time performance test methods and makes the real-time performance test of the Linux system more comprehensive and accurate.

The above descriptions are only preferred embodiments of the present invention, and do not limit the present invention. Any modifications, equivalent replacements and improvements made within the spirit and principle of the present invention shall be included in the protection scope of the present invention. Inside.

Claims (7)

1. A test method for measuring real-time performance of a Linux system is characterized by comprising the following steps of: the method comprises the following steps:

step one, constructing a special kernel module and a testing tool: the method comprises the steps of importing source codes into a Linux system for compiling, and compiling to generate a Linux kernel module and an executable file, wherein the executable file is a testing tool;

inserting the kernel module into a Linux kernel: inserting the kernel module into a Linux kernel, collecting kernel information according to the working content of the self-defined kernel module, and storing the collected information in the kernel module;

step three, determining and classifying test index items: distinguishing the test index items according to granularity, so that fine-granularity test points test through a kernel module to obtain data, and testing coarse-granularity test points in a user mode in a Linux system;

step four, executing user mode test: the user runs the executable file compiled in the step one, performs user state test point simulation, simulates a coarse-granularity simulation program, marks time stamps before and after the simulation process, and performs time period statistics to obtain test point data;

step five, testing the kernel module: triggering the events in the kernel operation through the set trace event in the kernel, realizing statistics of system parameters, subtracting time stamps of different event statistics to obtain delay of a tested demand point, and reacting to a user mode after obtaining delay data of the demand point in the kernel;

and step six, the kernel module combines the coarse-granularity simulation process and combines the kernel data collected from the steps to calculate and arrange, so as to output the real-time data of the Linux system which is concerned by the user.

2. The test method for measuring real-time performance of a Linux system according to claim 1, wherein the test method comprises the following steps: in the second step, the kernel module is inserted into the Linux kernel by using an insmod command.

3. The test method for measuring real-time performance of a Linux system according to claim 1, wherein the test method comprises the following steps: and in the third step, the test index item comprises interrupt response delay, semaphore operation delay, message queue operation delay, context switching delay, mutex operation delay, timer operation delay, event operation delay, task operation delay and scheduling operation delay.

4. The test method for measuring real-time performance of a Linux system according to claim 1, wherein the test method comprises the following steps: and in the third step, the standard for distinguishing the test index items is whether the packaging of the demand points can be realized.

5. The test method for measuring real-time performance of a Linux system according to claim 1, wherein the test method comprises the following steps: in the fifth step, the kernel module adopts a tracer technology, interacts with the kernel module through input of a user, sets and calls corresponding functions, acquires kernel module test data required by the user, and feeds back the test data to the user through a proc file system.

6. The test method for measuring real-time performance of a Linux system according to claim 5, wherein the test method comprises the following steps: the proc file system is a communication window of kernel mode and user mode in the Linux system, and a user observes real-time test data through the proc file system.

7. The test method for measuring real-time performance of a Linux system according to claim 1, wherein the test method comprises the following steps: and step six, the process of calculating and sorting the data is to process a large amount of time data acquired by cyclic test, the minimum value, the maximum value and the accumulation sum of the data item are updated each time the time data are acquired in each cycle, the accumulation sum is used for finally outputting an average value, and finally, the real-time quantized data of the Linux system concerned by the user is output.

Images