KR20080054324A - Method for allocation stack in multi-threaded sensor operating systems environment - Google Patents

Abstract

A method for allocation stack in a multi-threaded sensor OS(Operating System) environment is provided to allocate a thread stack with space efficiency in a sensor OS operated in a space restricted sensor platform and reduce usage of a memory space remarkably more than a usual static thread stack allocation method. A stack space used by a called function is allocated by estimating the size of the allocated stack space based on the size of local variables and the number of function factors used by the function when the function is called during execution of the thread(220). A stack pointer is moved to point the allocated stack space(230). A factor and a return address of the function are stored in the stack space(240). The function is returned when the function is terminated(270). The stack pointer is restored and the allocated stack space is returned(280).

Description

Stack Allocation Method in Multi-Thread-Based Sensor Operating System Environment {METHOD FOR ALLOCATION STACK IN MULTI-THREADED SENSOR OPERATING SYSTEMS ENVIRONMENT}

1 is a flowchart illustrating a stack allocation method in a multi-threaded sensor operating system environment according to an embodiment of the present invention.

2 is a flow chart illustrating the stack allocation method of FIG. 1 in more detail.

3 is a diagram illustrating an example of allocation of a stack area for comparing a stack allocation method in a multi-threaded sensor operating system environment according to an embodiment of the present invention and a static stack allocation method according to the related art.

4 is a graph illustrating a stack allocation for comparing a stack allocation method in a multi-threaded sensor operating system environment according to an embodiment of the present invention and a static stack allocation method according to the related art.

The present invention relates to a stack allocation method in a multi-threaded sensor operating system environment. More particularly, the present invention relates to stack allocation by dynamically allocating as much stack space as a thread requires. The stack allocation method in a multi-threaded sensor operating system environment can be utilized more efficiently.

In general, wireless sensor networks are wireless networks that sense various environmental information and process the information in the form desired by the user to communicate in real time. Such a wireless sensor network consists of hundreds or thousands of wireless sensor nodes. Each Sensor Node must be configured in a very small size in terms of cost, so that the entire network can be cost-effective. The sensor nodes are responsible for collecting environmental information, communicating with neighboring nodes, processing the information, and delivering the information to the user in real time.

That is, the sensor node includes a sensor for obtaining temperature, humidity and light quantity information, a central processing unit (CPU) for performing simple calculations, an RF module for wireless communication, a small ROM for booting, and It consists of a main battery. For example, the MICA series sensor platform, designed by the University of Berkeley, consists of an 8-bit central processing unit (CPU), 4KB of RAM, and two AA batteries.

The sensor operating system, which will operate on such a sensor platform, uses multi-threaded task management to efficiently process a large number of tasks such as sensing, communication, and transformation that can occur in a sensor node while using a limited memory space efficiently. Management technique is required.

To solve this problem, the existing static thread stack allocation method allocates a statically sized stack area for the thread when the thread is created. In other words, each thread must have its own stack allocated in memory space.

This allocation of stack area is a significant problem for sensor platforms with very limited memory space. If the thread does not use all the allocated stack space, the remaining space is a waste of stack space. Therefore, static allocation and return of stack memory space in space-constrained wireless sensor platforms can cause serious problems in terms of resource management.

This problem actually causes the memory shortage of the system, etc., and causes a malfunction of the entire wireless sensor network. There was no way to reliably solve the problem of using this multithreaded task management technique.

On the other hand, there is an attempt to solve the problem of memory space by using an event-based programming technique rather than a conventional multi-threaded technique, but such an event-based structure does not provide a preemption function for real-time task processing.

SUMMARY OF THE INVENTION The present invention has been made to solve the above-described problem, and an object of the present invention is to provide a space-efficient thread stack allocation method for a sensor operating system operating in a space-constrained sensor platform.

Another object of the present invention is to provide a stack allocation method in a multi-threaded sensor operating system environment that can significantly reduce the memory space usage than using a conventional static thread stack allocation method.

It is still another object of the present invention to provide a space efficient thread stack allocation method capable of performing multiple tasks in real time while efficiently using the entire memory space.

In order to achieve the above object, the dynamic stack allocation method in a multi-threaded sensor operating system environment according to the first aspect of the present invention, dynamic stack allocation to be used by the called function every time the function is called during the execution of the task of the thread. And returning the allocated stack area when execution of the function is terminated.

Advantageously, the method further comprises estimating the size of said stack area to be allocated based on the size of a local variable to be used by said function and the number of function arguments.

In another embodiment, the method further comprises estimating the size of the stack area to be allocated by analyzing assembly code corresponding to the function.

A dynamic stack allocation method in a multi-threaded sensor operating system environment according to the second aspect of the present invention includes the steps of: allocating a stack area to be used by the called function when a function is called during the execution of a thread; Moving a stack pointer to point to a stacked stack region, storing arguments and return addresses of the function in the stack region, returning the function when execution of the function is finished, and stack stack Restoring and returning the allocated stack region.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings. However, embodiments of the present invention illustrated below may be modified in many different forms, and the scope of the present invention is not limited to the embodiments described below. The embodiments of the present invention are provided to more completely explain the present invention to those skilled in the art.

First, the terms used in the present invention will be briefly described.

"Thread" means a unit of execution within a program. For example, in Java, each task is represented as a thread, and multi-tasking is possible by allowing several such threads.

"Function" refers to a unit, such as a standardized subroutine that performs a specific task in a program independently to produce a result. If you pass an argument to the function, the function returns the result for that argument.

1 is a flowchart illustrating a stack allocation method in a multi-threaded sensor operating system environment according to an embodiment of the present invention.

As shown, whenever a function is called while the thread is executing, the stack area allocated by the function is allocated (110).

In an embodiment of the present invention, the size of the stack area to be allocated may be estimated based on the size of the local variable and the number of function arguments used by the corresponding function. In addition, by analyzing the assembly code provided by the compiler when the program is compiled, it is possible to more accurately predict the size of the stack area to be used by the function. The program code at the C language level does not show the increase and decrease of the stack size of each function at the machine code level operating in the embedded system or sensor node. By analyzing, the stack area size can be predicted more accurately. Assembly code replaces machine code with assembly language. By analyzing this, the usage of stack area of each function can be accurately determined.

The result of measuring stack usage by each function is recorded in a separate file, and based on this information, a new stack area can be allocated at each function call.

 Therefore, according to the stack allocation method according to the present invention, it is possible to prevent stack overflow.

When execution of the function is terminated using the allocated stack space, the used stack area is returned (step 120).

Hereinafter, a stack area allocation method according to an embodiment of the present invention will be described in more detail with reference to FIG. 2.

Referring to FIG. 2, first, a thread to be executed in a multi-threaded sensor operating system environment is created (210). As described above, since the sensor operating system to operate in the sensor node needs to simultaneously execute a plurality of threads for processing a plurality of tasks such as sensing, communication, and transformation in real time, one or more threads may be generated.

In step 220, a stack area to be used by the function is allocated when a function is called while performing the work of the created thread. The prediction method of the stack region size has been described with reference to FIG. 1. That is, the stack area size can be predicted more accurately by estimating the stack area allocation based on the size of the local variable to be used by the function to be called and the number of function arguments, or by analyzing the assembly code corresponding to the function. Next, the stack pointer is moved to point to the stack area allocated in step 230. Before moving the stack pointer, save the current stack pointer for later restoration.

Next, in step 240, the argument and the return address of the function are stored on the stack.

Thereafter, the function is called and executed (250), and when the operation of the function is finished, the function returns again (260).

Finally, after restoring the stack pointer (270), the stack area allocated in step S200 is returned (280).

Table 1 below compares the static stack allocation method of the prior art and the dynamic stack allocation method according to an embodiment of the present invention by function.

Prior art The present invention Stack allocation When creating a thread When a function is called Stack allocation size silence dynamic How to call a function Same as normal function call Function call after stack allocation, stack return at function exit Stack allocation cost Only occurs once Can occur multiple times Stack Area Efficiency lowness height Maximum number of threads Inversely proportional to stack size Inverse to function nesting level Stack overflow Possible Does not occur

In the stack allocation method according to an embodiment of the present invention, since a stack area to be used by a thread is allocated every function call, a potential load may occur in terms of execution time. However, it is possible to improve the efficiency of the entire stack area, and because the maximum number of threads is inversely proportional to the level of nesting of the function rather than the size of the stack, more threads can be created than with the conventional stack-based thread allocation method. Will be.

3 is a diagram illustrating an example of allocation of a stack area for comparing a static stack allocation method of the related art with a dynamic stack allocation method according to an embodiment of the present invention. Specifically, when three threads (Thread 1, Thread 2 and Thread 3) each call at least two to at most four functions, an example of using the memory of the entire system according to the prior art and the present invention is shown.

3 (a) shows that waste of the stack area occurs when the stack areas T1, T2, and T3 are allocated to each thread according to the related art. On the other hand, Figure 3 (b) shows that when the stack area is allocated for each function call of each thread according to the present invention, the remaining area is preserved as a free area so that the waste of the stack area does not occur.

That is, when using the dynamic stack allocation method according to an embodiment of the present invention, it is possible to minimize the waste of space in the stack area, thereby significantly reducing the overall stack usage.

4 is a graph illustrating stack allocation for comparing a stack allocation method and a conventional static stack allocation method in a multi-threaded sensor operating system environment according to an embodiment of the present invention. You can see that using an in-stack allocation method works very space efficiently.

As described above, the stack allocation method in a multi-threaded sensor operating system environment according to an embodiment of the present invention dynamically allocates as many stack regions as a thread requires. This is done for each function call in each thread, and when the function exits, it returns the stack so that other threads can reuse that space. Using the stack allocation method of the present invention, although there is a time load of allocating and returning memory space, the entire memory space can be efficiently used.

Therefore, in the space-constrained wireless sensor operating system, it is easy to solve the memory shortage problem when using the multi-threaded task management technique. In addition, stack overflow problems can be prevented, which can be very useful in microcomputer systems such as wireless sensor nodes without a memory management unit (MMU).

The invention described above may be provided as one or more computer readable media embodied on one or more articles of manufacture. The article of manufacture may be a floppy disk, a hard disk, a CD ROM, a flash memory card, a PROM, a RAM, a ROM, or a magnetic tape. Generally, computer readable programs can be implemented in any programming language. Some examples of languages that can be used include C, C ++, or JAVA.

In the above, embodiments of the present invention have been described, but the present invention is not limited thereto, and various modifications and changes can be made within the scope of the claims and the detailed description of the invention and the accompanying drawings. Belongs to the present invention.

According to the present invention as described above, by dynamically allocating as much stack area as the thread requires, it is possible to significantly reduce the memory space usage than using the conventional static thread stack allocation method. In addition, stack overflow problems can be prevented, which can be very useful in a small computer system such as a wireless sensor node without a memory management unit (MMU).

Claims (10)

A dynamic stack allocation method in a multi-threaded sensor operating system environment, Dynamically allocating a stack region to be used by the called function each time a function is called while executing a thread's work; Returning the allocated stack area when execution of the function is terminated. Dynamic stack allocation method in a multi-threaded sensor operating system environment including a. The method of claim 1, Estimating the size of the stack area to be allocated based on the size of a local variable to be used by the function and the number of function arguments. The method of claim 1, Estimating the size of the stack area to be allocated by analyzing assembly code corresponding to the function. The method according to claim 2 or 3, Storing size information of the predicted stack area; A dynamic stack allocation method in a multi-threaded sensor operating system environment in which a stack region is allocated based on the size information of the stored stack region. A dynamic stack allocation method in a multi-threaded sensor operating system environment, Allocating a stack area to be used by the called function when the function is called during the execution of a thread; Moving a stack pointer to point to the allocated stack area; Storing the argument and return address of the function in the stack area; When the execution of the function is finished, returning the function; Restoring the stack pointer and returning the allocated stack area Dynamic stack allocation method in a multi-threaded sensor operating system environment including a. The method of claim 5, Estimating the size of the stack area to be allocated based on the size of a local variable to be used by the function and the number of function arguments. The method of claim 5, Estimating the size of the stack area to be allocated by analyzing assembly code corresponding to the function. The method according to claim 6 or 7, Storing size information of the predicted stack area; A dynamic stack allocation method in a multi-threaded sensor operating system environment in which a stack region is allocated based on the size information of the stored stack region. A computer-readable recording medium having recorded thereon a computer program for performing the dynamic stack allocation method according to claim 1. 10. The computer program product of claim 9, wherein the computer program is executed at a sensor node having a limited size of memory.

Images