JPS63172346A - Stack allocating method - Google Patents

Abstract

PURPOSE:To effectively utilize a memory by setting previously the initial value of a proper stack size at a table updating the initial value with the value added with the stack extension value when a stack extension request is produced and at the same time allocating the stacks by the number equal to the size stored in a corresponding table when a task is started. CONSTITUTION:An operating system OS searches a task execution waiting list to decide a desired task and starts this task. In this case, a physical memory is secured for the stack allocation size l stored in a control table TCB and a mapping task is carried out to a logic space. If the stacks run short in an execution mode, the OS secures a physical memory to the short staks and has a mapping task to a logical space. Then the extended size (m) is added to the size l in the TCB. When a task is through and set under an execution enable state, the task is registered again into the task execution waiting list. Then a stack physical memory having a size (l-m) changed when the task is started in the preceding time is secured when a task is started by the OS.

Description

DETAILED DESCRIPTION OF THE INVENTION (Field of Industrial Application) The present invention relates to a stack allocation method for allocating a working stack area to each task in a virtual memory computer system.

(Prior art) When a task is executed in a virtual memory computer system, text and data are first loaded from the magnetic disk device into the main memory by the O8 (operating system) when the task is started, and then loaded into the work area. A stack area is also allocated on the main memory.As a method of allocating this stack area, for example,
As disclosed in No. 27963, there is a method of requesting expansion of the stack area when necessary during task execution, and a method of securing the necessary stack area in advance when starting a task.

[Problem that the invention seeks to solve]

The above conventional techniques had problems with system overhead and efficient use of memory. For example, in the former method of dynamically expanding the stack during task execution, O8 processing intervenes every time the stack is expanded. Therefore, an increase in overhead cannot be avoided.In addition, in the case of the latter method of allocating a stack of the required size when starting a task, in order to prevent the stack area from running out during execution, it is necessary to allocate more stacks than necessary. Although it is possible to determine the optimal stack size by manual calculation or simulation, which reduces memory usage efficiency, it takes a lot of effort.

An object of the present invention is to provide a stack allocation method that does not increase overhead and can realize efficient memory usage.

[Means for solving problems]

The purpose of the above is to create a table for each task to store the stack size, set an appropriate initial value for the stack size in this table so as not to waste memory, and then expand the stack when the task is executed. When a request occurs, the table contents are updated to a value that adds the amount expanded at that time to the size stored in this table, and when a task is started, only the size stored in the table corresponding to the task being started is updated. This is accomplished by allocating a stack.

[Effect]

The stack size allocated at task startup is the maximum stack size required during the previous task operation, so the probability that a stack expansion request will occur during task operation is naturally small, and the overhead associated with stack expansion is reduced. This will prevent an increase in Furthermore, since the stack size allocated at the time of starting a task is the size actually required during the previous task operation, an unnecessarily large stack size is not allocated, and efficient use of memory is guaranteed.

〔Example〕

An embodiment of the present invention will be described below. FIG. 4 shows an example of a computer system 1 to which the method of the present invention is applied. Central processing group [4 is the memory management bag! ! 5. It is connected to the main memory 6 through the memory bus 3, and to the I10 management unit W17 through the system bus 2. O8
and each task are stored in a secondary storage device such as a disk (not shown) connected to the management device 7 of the system 10, and loaded onto the main memory 6 at startup or as needed.

O8 and tasks are executed by the central processing unit 4, but all accesses to the main memory 6 are performed in logical space through the memory management units 2!5.

FIG. 5 is a diagram showing the relationship between the logical space managed by the memory management device 5 and physical memory.

In the logical space, the task currently being executed (task 1 in the figure) is displayed.
) and O8 areas are mapped to physical memory.

The task has text area TI, data area D1 . The stack area S1 is divided into three areas. Task 1 has finished and task 2 is waiting.
Next, when task 2 is activated by O8 and is running,
The text, data, and stack area of Task 2 are mapped to the logical space. However, stack area mapping is the allocation of the stack area to physical memory, which will be discussed in detail later. Furthermore, the user area of the logical space is mapped to a separate area of the physical memory each time a task is switched, but the O8 area is always mapped to a fixed area (OS area) of the physical memory. This is necessary for O8 to control logical space, physical memory, and all tasks.

FIG. 6 is a diagram showing a method of converting an address from a logical address to a physical address by the memory management device 5. This is a very common method of memory access in virtual memory systems, and the address part of an instruction is all written as a logical address. This logical address space is typically divided into 4 Mbyte segments, and each segment is further divided into 4 byte pages. A segment table and a page table are placed on the main memory, and these tables show the correspondence between logical addresses and physical addresses on the main memory, and the memory management device 5 refers to these tables to determine the logical address. Converts to a physical address and executes the address to main memory.

FIG. 7 is a diagram showing the state transition of tasks.

A new task or an unregistered task is generated by a task generation macro and becomes dormant. In this state, the second
The task management table (TCB) shown in the figure is secured,
The task number specified by the task generation macro is set, the task status becomes inactive, and the stack allocation size is set to the initial allocation size (for example, 2 pages), which will be described later.

A task in a dormant state only has a TCB generated,
When a task becomes executable by the task suspend release macro and the text area or data area has not yet been loaded on the physical memory, an area is secured on the physical memory as explained in Figure 5, and the area is read from the auxiliary storage device. Text and data are loaded.

A task in an executable state has a text area and a data area loaded into the main memory, so it is ready to operate at any time, but since it is not subject to O8 scheduling, it will not be started as it is. In order to execute a task, it is necessary to register the TCB'& in the task execution waiting list (described later) shown in FIG. Here, the task becomes the target of OS scheduling for the first time.

It is in the running or waiting state. During execution, the central processing unit (CPU) time is allocated.

This is the state in which instructions are actually being executed. Waiting refers to the state in which the CPU is waiting for scheduling, such as when the CPU time has been occupied for more than a certain period of time and the CPU has been given over to another task. show.

Note that stack physical memory is allocated to a task when the task is first started, and is not released until the task is terminated or forcibly terminated and becomes executable or dormant. When the task is completed or forcibly terminated, the TCB is removed from the waiting list.

However, even in this case, the TCB itself does not disappear unless the task is deleted.

FIG. 2 and FIG. 8 show the configuration of the TCB and the task execution waiting list.

It is created when the task goes dormant and is saved until the task is deleted. The task execution waiting pointer in the TCB is used when registering a task to the execution waiting list, and the task status flag is used to store the task status shown in FIG. The stack allocation size is the central feature of this patent, and is used to remember the capacity of physical stack memory to be secured when starting a task.

The task execution waiting list is used by the O8 to retrieve tasks to be activated. Note that there are as many task execution wait pointers as there are priority levels.

Each TCB is connected for each priority level.

Based on the above explanation, the general operation of the stack allocation method of the present invention will be explained with reference to FIG. The O8 searches the task execution waiting list, determines the task to be started, and starts the task. At that time, as shown in (1) in the same figure, the physical memory of the stack allocation size l stored in the TCB is If this is the first time the task is activated after task generation, the stack allocation size in the TCB is the initial allocation size, and if the task has already been executed at least once, If so, it is the maximum stack size used up to the previous time.

Now, when this task is started and there is a shortage of stacks during execution, as shown in Figure 3 (2), O8 secures physical memory for the missing stack and performs logical space and mapping. do. Then, the expanded size m is added to the stack allocation size l in the TCB. As a result, the stack allocation size as shown in FIG. 3(3) becomes l+m.

After the task has finished and is ready to run.

When the task is registered in the task execution waiting list again and the task is activated by O8, a physical memory for the stack of the value 1+m size that was changed during the previous task operation is secured.

In reality, there may be cases where a task goes out of control and expands the stack infinitely, but in that case, it is considered an abnormality, the task is forcibly terminated, and the stack allocation size in the TCB is set to the initial allocation size. This operation is performed to prevent the stack allocation size from increasing unreasonably.

FIGS. 1A to 1D are flowcharts showing one embodiment of the O8 process for implementing the method of the present invention. First, FIG. 1A shows the processing content of O8 at the time of task activation. In step 101, the task with the highest priority level is extracted from the task execution waiting list shown in FIG. 8. In the next step 102, the extracted task is In step 103, the logical space of the text part and the data part is mapped to the physical space as shown in FIG.
The physical memory for the stack is secured for the stack allocation size l in the stack allocation size l, and is mapped with the logical space. As mentioned above, the value of 1 is set to the initial value when the task is initially started or when it is reset due to some abnormal occurrence, and when the task is normally used and expanded, it is set to the initial value as described later. The size includes the expansion, as shown in the figure.

Once the stack is secured in this way, a task is activated in step 104.

Figure 1B shows the content of O8 processing when a stack expansion request occurs. In step 111, a new physical memory for the stack is secured by the size m to be expanded, and this is mapped with the logical space. In step 112, the memory for the stack is Increase the stack allocation size in the TCB by m, and l+m
shall be. The task is thus restarted in step 113.

Next, FIG. 1C shows the processing content of O8 when a task is forcibly terminated. When task 7 is forcibly terminated, the task has runaway due to some abnormality, and the stack area has been expanded significantly and unnecessarily. In this case, first return the stack allocation size in the TCB to its initial value in step 121, set the task status in the TCB to dormant in step 122, and then set the task in step 123 to the initial value. Terminate it.

FIG. 1D shows the processing contents of O8 when the task is normally completed. In this case, the task state of the TCB is made executable in step 131, and the task is ended in step 132.

FIG. 9 is a graph of the average number of times stack expansion requests are generated for each task activation in the case of stack allocation using this method for the same task and in the case of dynamically expanding the stack during execution. Note that the number of stack expansion requests generated is normalized to 1.0 in the case of dynamic stack allocation. This figure shows that in this method, stack expansion requests are hardly generated after a certain amount of time has passed after the initial startup of a task, and the overhead of stack expansion can be significantly reduced compared to the case where the stack is expanded dynamically. There is.

As described above, by feeding back the stack size required at the time of task execution to the stack allocation size in the TCB, it is possible to realize optimal stack allocation at the time of task activation.

〔Effect of the invention〕

According to the present invention, since the minimum stack required for executing a task can be allocated at the time of task activation, it is possible to reduce the overhead that occurs when expanding the stack and to make efficient use of memory.

[Brief explanation of the drawing]

Figures 1A to 1D are flowcharts showing an example of O8 processing that implements the method of the present invention, Figure 2 is a diagram showing the structure of a task management table, and Figure 3 is a schematic diagram of the operation of the method of the present invention. 4 is a diagram showing a configuration example of a system to which the present invention is applied, FIG. 5 is a diagram showing the relationship between logical space and physical memory, and FIG. 6 is a diagram showing an address conversion method from a logical address to a physical address. The explanatory diagram, FIG. 7, is a state transition diagram of a task. FIG. 8 is a diagram showing a task execution waiting list, and FIG. 9' is a diagram comparing operations between the method of the present invention and conventional dynamic allocation. 4...Central processing unit, 5...Memory management device, 6.
...Main memory, 7...I10 management device.

Claims (1)

[Claims] 1. In a task management table corresponding to each task for managing each task executed in a computer system using a virtual storage method, a stack allocation size is provided as a column representing the size of the stack used in the task, and
When creating a task or forcibly terminating a task, set a predetermined initial value to the corresponding stack allocation size,
When a stack expansion request occurs, the stack size after expanding to the corresponding stack allocation size is set, and when a task is started, a stack area corresponding to the above stack allocation size corresponding to the task is secured in physical space and this is logically A stack allocation method characterized in that the task is started after being mapped to a space.