KR100651722B1 - Method of configuring Linux kernel for supporting real time performance and test method for supporting real time performance - Google Patents

Abstract

A Linux kernel configuration method and a real-time performance test method are disclosed. A method of configuring a Linux kernel according to the present invention includes: performing a low priority transfer task; Determining whether the Linux kernel is in user mode or kernel mode when an interrupt requesting service for a high priority task occurs; If the Linux kernel is in kernel mode, determining whether another task of high priority exists; And performing the high priority task through rescheduling if another task of the high priority does not exist. According to the present invention, it is possible to optimize the real-time response performance of the information appliances application product employing Linux as the operating system, it is possible to more accurately test the real-time response performance of the information appliances application products.

Description

Method of configuring Linux kernel for supporting real time performance and test method for supporting real time performance}

1A and 1B are diagrams for showing a difference between a preemptive kernel and a non-preemptive kernel,

2 is a flowchart of a preemptive kernel method for real-time performance support of a Linux kernel according to an embodiment of the present invention;

3 is a reference diagram for explaining a preemption point insertion method according to an embodiment of the present invention;

4A and 4B are reference diagrams for describing an interrupt processing prioritization method according to an embodiment of the present invention;

5 is a reference diagram for explaining a priority support synchronization method according to an embodiment of the present invention;

6 is a diagram illustrating a task preemption delay time indicating real time response performance according to the present invention.

The present invention relates to a Linux kernel, and more particularly, to a configuration method and a real-time performance test method of the Linux kernel for real-time performance support.

In recent years, information electronics products under development are converged, unlike previous products, and have functions to communicate and cooperate with each other. In the case of a home server, many applications such as Internet shopping, user demanded video streaming (VOD), and internet access from outside the home are controlled by the home server. The demand for applications is increasing. In addition to these real-time demands, there is also a growing number of Linux products that can contribute to lowering the price of these information appliances. The release of information appliances application products using existing MS or dedicated real-time operating system can enjoy stability using existing products, but there is a burden due to high cost. One way to solve the high cost problem is to use Linux.

Linux is the basic computer operating system that made Unix, the operating system that used to work on large models, to run on small PCs. Linux has the advantage that the program source code is freely available, so that programmers can add specific features as they wish, and even port them to any platform.

When using Linux as the operating system of information appliances applications, it has a cost advantage by using various open solutions, but has a problem in real time performance due to the inherent limitations. The inherent limitation of Linux is that Linux is composed of a monolithic kernel similar to a typical Unix kernel, and there is a problem in real-time performance because it cannot immediately react to events in the system when entering kernel mode from user mode. Is that.

The kernel, on the other hand, is the most important core of a computer operating system and provides several basic services to all other parts of the operating system. In general, the kernel has an interrupt handler that handles all requests that competitively require kernel services, such as terminated I / O operations, and a scheduler that determines which programs will share the kernel's processing time and in what order. It includes a supervisor that gives each process a license to the computer. The kernel also has a memory manager that manages the operating system's address space in memory or storage and distributes it to all peripherals and other users of the kernel's services. Kernel services are requested through different parts of the operating system or through a set of program interfaces known as system calls. Because the code to maintain the kernel is used continuously, the kernel is usually loaded in a protected memory area so that it is not overwritten by the rest of the less frequently used operating system.

1A and 1B are diagrams illustrating the difference between a preemptive kernel and a non-preemptive kernel. FIG. 1A shows a driving method when an urgent task occurs in the non-preemptive kernel, and FIG. 1B shows a driving method when an urgent task occurs in the preemptive kernel. The non-preemptive kernel here is the traditional standard Linux.

In both the preemptive kernel and the non-preemptive kernel, user mode can preempt a running task when an urgent task occurs. However, when a running task enters kernel mode to receive kernel services, the preemptive kernel and the non-preemptive kernel run differently.

Referring to FIG. 1A, when an urgent task occurs in a non-preemptive kernel, the non-preemptive kernel checks that a high priority urgent task has occurred, runs the original task that was run in kernel mode, and then executes a high priority urgent task. Perform the task. 1B, the preemptive kernel first executes a high priority urgent task and then runs the original task that was running in kernel mode. Therefore, it can be said to be a kernel structure suitable for more real-time performance. The ISR is a signal indicating that a high priority urgent task has occurred.

As discussed above, the Linux kernel, a kind of non-preemptive kernel, has problems with real-time performance.

SUMMARY OF THE INVENTION The present invention has been made in an effort to provide a method for configuring a Linux kernel for real-time performance support, and a recording medium on which a program for realizing the method is recorded.

Another technical problem to be achieved by the present invention is to provide a real-time performance test method of the Linux kernel.

Linux kernel configuration method for real-time performance support according to an aspect of the present invention for achieving the above object,

Performing a low priority previous task; Determining whether the Linux kernel is in user mode or kernel mode when an interrupt requesting service for a high priority task occurs; If the Linux kernel is in kernel mode, determining whether another task of high priority exists; And performing the high priority task through rescheduling if another task of the high priority does not exist.

According to another aspect of the present invention, a method of configuring a Linux kernel for real-time performance support, by placing a preemption point in a critical region within the Linux kernel, if a high priority task exists in the preemption point of the high priority The method further includes performing a task.

According to another aspect of the present invention, a method of configuring a Linux kernel for real-time performance support, the Linux kernel includes an upper half processing step and a lower half processing step in the interrupt processing, the upper half processing step thread the interrupt handler And scheduling according to the priority of the task.

According to another aspect of the present invention, the Linux kernel configuration method for the real-time performance support, wherein the lower half processing step, the order of the tasks present in the lower half processing thread queue according to the priority for each occurrence of the lower half processing event. It includes a step.

According to another aspect of the present invention, a method of configuring a Linux kernel for supporting the real-time performance, the method comprising the step of sorting the tasks according to the priority each time a task arrival event occurs in the synchronization interface of the Linux kernel desirable.

Real-time performance test method of the Linux kernel according to an aspect of the present invention for achieving the above another technical problem,

Measuring an interrupt processing delay time, which is an interrupt handler processing time for an interrupt requesting a service for a current task; Measuring a scheduler arrival delay time, which is a delay time until the current task reaches a scheduler; Measuring, by the scheduler, a scheduler processing delay time which is a time required for scheduling of the current task; And determining the task preemption delay time representing the real-time response performance of the Linux kernel by adding the interrupt processing delay time, the scheduler arrival delay time, and the scheduler processing delay time.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings. In adding reference numerals to the components of each drawing, the same components are denoted by the same reference numerals even if they are shown on different drawings. In addition, in the following description there are shown a number of specific details, such as components of the specific circuit, which are provided to aid a more general understanding of the invention, it is to be understood that the present invention may be practiced without these specific details. It will be self-evident to those of ordinary knowledge. In describing the present invention, when it is determined that detailed descriptions of related known functions or configurations may obscure the gist of the present invention, the detailed description thereof will be omitted.

First, a method of configuring a Linux kernel for real-time performance support according to the present invention will be described. In the present invention, a preemptive kernel method, a preemptive point insertion method, an interrupt processing prioritization method, and a priority support synchronization method are used for real-time performance support of the Linux kernel.

2 is a flowchart of a preemptive kernel method for real-time performance support of a Linux kernel according to an embodiment of the present invention. First, in a state where a low priority task is running in the Linux kernel according to an embodiment of the present invention (S110), if an interrupt requesting service for a high priority task occurs (S120), first, interrupt service Run the routine.

If the interrupt service routine needs to wake up another task, it wakes up another task and sets a predetermined variable value indicating that the scheduler needs rescheduling. Then, when the interrupt service routine is finished, it is checked whether the Linux kernel is in user mode or kernel mode (S130). If the user mode can be rescheduled at any time in the conventional preemptive kernel, the same processing routine as in the conventional standard Linux is performed (S140).

In kernel mode, however, it checks to see if rescheduling is possible within the kernel. That is, after checking whether another task of high priority exists (S150), if another task of high priority does not exist, rescheduling is performed to perform the high priority task generated in step 120 ( S160). Thereafter, the task of priority is performed (S170).

Next, a preemption point insertion method according to an embodiment of the present invention will be described. 3 is a reference diagram for explaining a preemptive point insertion method according to an embodiment of the present invention. Inside the kernel, there is a critical section to protect shared resources that tasks try to access simultaneously. This critical area is protected by a shared resource protection interface, commonly referred to as a lock. In general, if the task is inside the critical area, it is not implemented. The reason for this is to maintain consistency in the kernel data because it is a shared resource used by multiple tasks. However, in some cases, preemption is possible even if a task enters inside this critical area. In this case, a voluntary preemption point can be placed inside the critical area to check whether the task has an urgent task in advance, and if there is an urgent task, it can immediately transfer control of the CPU to reduce the task preemption delay.

Next, an interrupt processing prioritization method according to an embodiment of the present invention will be described. 4A and 4B are reference diagrams for describing an interrupt processing prioritization method according to an embodiment of the present invention. Linux's interrupt handling structure is divided into upper and lower half. The upper half improves responsiveness by doing minimal work in the event of an interrupt and transferring control to the lower half in the shortest possible time. After that, the rest of the work is done in the bottom half of the system. However, from the standpoint of supporting real-time performance, the upper half processing process and the lower half processing process of the interrupt processing in Linux have problems.

First, the upper half processing part is processed first when an interrupt occurs, so that the code can be returned as soon as possible and control is returned as soon as possible. However, there is no concept of priority between interrupts occurring during interrupt processing, which leads to problems in the priority handling structure for higher priority interrupts, which means increased preemption latency. Accordingly, in the present invention, as shown in FIG. 4A, the interrupt handlers may be threaded to be scheduled according to the priority so that the interrupt handlers have priority in the upper half interrupt structure.

Next, although the lower half processing handler is driven at the time when the system is left, the conventional Linux processes the tasks sequentially in the sequential lower half processing thread queue, which can hinder the real-time performance of preferentially servicing the CPU. Accordingly, in the present invention, as shown in FIG. 4B, the order of the jobs in the sequential lower half processing thread queue is executed based on the priority based on the priority of each occurrence of the lower half processing event.

Next, a priority support synchronization method according to an embodiment of the present invention will be described. 5 is a reference diagram illustrating a priority support synchronization method according to an embodiment of the present invention. Synchronization means protecting shared resources with a synchronization interface called lock in order to maintain consistency of shared resources within the system. In the conventional Linux, the synchronization interface does not have a processing structure according to priority when tasks simultaneously access a synchronization interface protecting shared resources, and may be performed differently in some cases. This can be viewed as a factor that hinders real-time performance, although tasks with higher priorities must be prioritized to improve real-time performance.

Accordingly, in the present invention, as shown in FIG. 5, queues of tasks such as T (A), T (B), and T (C) attempting to access shared resources in the synchronization interface 310 are maintained separately. Whenever a task arrival event occurs in the synchronization interface, the queue of tasks is sorted based on priority. By sequentially executing the queues 330 of the tasks arranged according to the priority according to the priority, it is possible to increase the real-time performance for the task having a high priority.

In the above, the Linux kernel configuration method for real-time performance support according to the present invention has been described. Hereinafter will be described a real-time performance test method of the Linux kernel according to the present invention.

The degree of real-time performance support of information appliances application products aimed at by the present invention is a guarantee time guaranteeing 99.999% of preemption delay time, which is one of the indicators that can be used as a criterion for real-time performance. Conventional Linux kernels can take up to several tens of milliseconds to provide real-time performance problems when loaded into information appliances. Depending on the application, a 99.999% guaranteed time is typically within a few hundred microseconds before it can be incorporated into an information appliance.

6 is a diagram illustrating a task preemption delay time indicating real time response performance according to the present invention. Referring to FIG. 6, the task preemption delay time is the sum of the interrupt processing delay time, the scheduler arrival delay time, and the scheduler processing delay time. The practical meaning of the task preemption delay is that of the task that was started when an urgent task to be run suddenly occurred in the system. It takes time to preempt CPU resources to service urgent tasks. Interrupt arrival delay is a delay that arrives to the embedded operating system kernel due to hardware interrupt, and can be ignored because it is slightly different in hardware and is very small.

Interrupt processing delay time is the interrupt handler processing time for the corresponding interrupt, which is time for each interrupt or depending on the interrupt processing method. Next, the scheduler arrival delay is not the service that is immediately serviced by the task after the interrupt handler has been processed, but the CPU resource that is serviced by the urgent task through the scheduler. . In general, this part of the Linux kernel is time-consuming.

Finally, the scheduler processing delay time means the time taken while the scheduler schedules.

A specific method of measuring task preemption latency is to run a high-load application into the embedded operating system kernel and then generate an interrupt to measure the time between read () system calls. This means that the read () system call causes the task to enter the kernel, interrupt, and wake up the task artificially to measure the time it takes to service the task.

As described above, the Linux kernel configuration method and the real-time performance test method for real-time performance support can be implemented as computer-readable code on a computer-readable recording medium. Computer-readable recording media include any type of recording device that stores data that can be read by a computer system. Examples of computer-readable recording media include ROM, RAM, CD-ROM, magnetic tape, floppy disks, optical data storage devices, and the like, and may also be implemented in the form of a carrier wave (for example, transmission over the Internet). It includes being. The computer readable recording medium can also be distributed over network coupled computer systems so that the computer readable code is stored and executed in a distributed fashion.

So far I looked at the center of the preferred embodiment for the present invention. Those skilled in the art will appreciate that the present invention can be implemented in a modified form without departing from the essential features of the present invention. The scope of the present invention is shown in the claims rather than the foregoing description, and all differences within the scope will be construed as being included in the present invention.

 As described above, according to the present invention, it is possible to optimize the real-time response performance of an information appliance application product employing Linux as an operating system, and to more accurately test the real-time response performance of an information appliance application product.

Claims (6)

A method of configuring an embedded Linux kernel for supporting real-time response performance, the method comprising: generating an interrupt requesting a service for a task having a higher priority than the previous task while performing a previous task having a low priority; Determining whether the Linux kernel is user mode or kernel mode; Determining whether rescheduling is possible for priority processing of the high priority task in the kernel when the Linux kernel is in kernel mode; And If the rescheduling is possible, stopping the execution of the previous task and performing the high priority task through the rescheduling. According to claim 1, Placing a preemption point in a critical region within the Linux kernel to perform the high priority task if a high priority task exists at the preemption point. The system of claim 1, wherein the Linux kernel includes an upper half processing step and a lower half processing step in interrupt processing. And said upper half processing step comprises prioritizing an interrupt handler and threading said interrupt handler to schedule according to said assigned priority. The method of claim 3, wherein the second half processing step Whenever a lower half processing event occurs, the tasks existing in the lower half thread queue are sorted according to the given priority and executed according to the given priority. According to claim 1, And sorting tasks according to priorities whenever a task arrival event occurs in the synchronization interface of the Linux kernel. In the real-time response performance test method of the Linux kernel, Measuring an interrupt processing delay time, which is an interrupt handler processing time for an interrupt requesting a service for a current task; Measuring a scheduler arrival delay time, which is a delay time until the current task reaches a scheduler; Measuring, by the scheduler, a scheduler processing delay time which is a time required for scheduling of the current task; And Determining the task preemption delay that represents the Linux kernel's real-time response performance by adding the interrupt processing delay time, the scheduler arrival delay time, and the scheduler processing delay time.

Images