JPH076045A - Memory managing method of multi-processing system - Google Patents

Abstract

PURPOSE:To improve the memory use efficiency of the real-time multi-processing system which uses tasks. CONSTITUTION:When a task in a state (a) enters a stable state (long-period process interruption), effective data are saved (arrow 43) in an effective data area 42 assigned (arrow 41) separately from a stack, which is released (arrow 44), so that memory enters a state (b). When the task is restarted in the stable state (b), a stack is re-allocated (arrow 45) and then the effective data are reloaded (arrow 46) onto the stack from the effective data area 42. The effective data area which becomes unnecessary is released (arrow 47) or still allocated for next-time stand-by operation. In the latter case, the effective data area is released when the stack is deleted. Whether the effective data are saved or not and the address of the effective data area are recorded in areas 48 and 32 of a task control block.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a memory management method in a multi-processing system (multi-task system),
In particular, the present invention relates to a memory management method that can reduce the amount of memory required for the entire multiprocessing system.

[0002]

2. Description of the Related Art In the field of information processing, a multi-processing system has been well known in the prior art, which is capable of processing a large amount of data at high speed by performing a plurality of processes substantially in parallel. In such a multi-processing system, it is usual to divide all processing programs into one or more processing units to control simultaneous parallel processing. The processing unit in that case is called a "task". Therefore, in a multiprocessing system, a plurality of tasks are logically executed simultaneously.

Generally, task processing proceeds according to a state transition model as shown in FIG. The task states are ready state and active state.
A task that constitutes a job has three states, a state and a wait state, and is usually executed while repeating these three states. In FIG. 8, the state transitions 1 to 6 will be briefly described. 1 is a transition in which the job step is attached as a task and the task control block TCB is placed in the ready queue. 2 is a transition in which the control right of the CPU is passed when the corresponding active task has a higher priority than any of the other operable tasks, and the task is executed and becomes active. 3 is some event (for example, input / output)
Task is in a wait state (wait s
tate). 4 is a transition in which the task moves to the ready state when the waiting event is completed. Reference numeral 5 is a transition in which a task having a higher priority than an active task becomes operable, so that the task yields the CPU control right and is returned to the operable state again. 6 is a transition when the execution of the task is completed, in which case the TCB is deleted from the ready queue and the various resources used by the task are released and can be used by the system. (See Jun Emura, "Structural Approach to Operating Systems (2)" (published on July 10, 1982 by the Japan Computer Association) P.653-654)

Next, the task will be described in more detail with reference to FIG. In FIG. 9, 11 is a task, 12 is a task control block TCB that stores the execution state of the program assigned to the task, and 13 is a work memory area managed by the last-in first-out (LIFO) used by the program. It is a stack. As shown in the figure, the task 11 is composed of two tasks, a task control block 12 and a stack 13. The stack 13 is used while expanding or contracting in a certain direction of an address (from a low-order address to a high-order address or from a high-order address to a low-order address). A push operation 14 adds valid data to the stack and pops (po
p) Operation 15 is an operation for fetching data from the stack 13, and valid data 16 on the stack is in the continuous memory area. The stack pointer SP indicates how much the stack is used, that is, how much valid data is stored (arrow 17). The task control block 12 has an area 18 for storing the top address of the stack 13 and an area 19 for storing the stack pointer. The task 11 is created when the program is executed and deleted when the program ends. The task control block and stack are allocated when the task is created,
These are released when the task is deleted.

In a general-purpose information processing system, there is a virtual storage system as a system for reducing the required main memory capacity. This is a system for temporarily saving the data in the main memory to an external storage device such as a disk. Since input / output processing for saving / restoring memory data is required, the processing is delayed, which is not suitable for a real-time processing system that requires high-speed processing. Further, the virtual memory system requires an external memory device, and therefore cannot be applied to an embedded system that is often used in a real-time system. Furthermore, the saving of data in the main memory is performed when the memory capacity is insufficient, but in general, insufficient memory capacity is likely to occur when the load is high. There is a risk that processing requirements will not be met.

Further, in the conventional exchange program,
A data storage area (which is called a transaction memory) is provided for each processing unit of multiple processing, and this processing is carried between processing programs to realize multiple processing. Only the data that needs to be handed over to the process is stored in another memory area and the transaction memory is released to reduce the required memory amount. This method has the effect of reducing the amount of memory without sacrificing processing efficiency, but since the application side must design the data structure of the transaction memory in consideration of multiple processing, the program becomes complicated and However, there was an adverse effect that the productivity and maintainability of the machine were impaired.

Using a real-time operating system,
By using a task as a multi-processing unit, the program structure of the multi-processing system can be improved. The transaction memory in the exchange program corresponds to the stack in the task, and the data allocation on the stack is automatically allocated according to the progress of the program, and corresponds to the design of the data structure of the transaction memory.

In the conventional multi-processing system using the real-time operating system, the stack allocated to the task remains allocated to the task until its execution is completed (the task is deleted at the transition 6). . Therefore, in order to release the memory, the data to be carried over to the next process must be saved in another memory area and then the task must be deleted. In order to perform the next process, the task must be recreated ( Need to attach).
This increases the processing overhead and complicates the program structure.

[0009]

In the conventional method, when the number of tasks is large and the processing time of the tasks is shorter than the existing time of the tasks, the amount of memory required for allocating the stack becomes enormous. Also, the total time required for the stack is much smaller than the system operation time. That is, the memory usage efficiency is poor. It is an object of the present invention to provide a method for improving memory usage efficiency in a task-based real-time multiprocessing system.

[0010]

In order to achieve the above object, the present invention provides a work area (stack) managed by an execution program and last-in first-out (LIFO) in a multi-processing system in which a plurality of programs are operated in a multiplexed manner. When a processing unit (task) consisting of () is not executed for a predetermined period, the area except the valid data in the stack allocated to the above task is temporarily released, and the required memory is re-established when the program restarts. It is characterized by allocation.

[0011]

According to the present invention, in a multi-processing system, when a task is not executed for a predetermined period, an area of the stack allocated to the task excluding valid data is temporarily released and the program is restarted. Since the required memory is reallocated, the memory usage efficiency is improved.

[0012]

BEST MODE FOR CARRYING OUT THE INVENTION In a multiprocessing system, each task progresses along the task state transition model as described above. In this case, the task may not be executed for a long period of time in a certain stable state (waiting state). The present invention improves the memory usage efficiency by releasing the stack in this case. A process therefor will be described with reference to FIG. A task consists of a task control block TCB and a stack and is executed. The state of the task at this time is shown in (a). After that, when it is detected that the task is not executed for a long time (waiting state) by a condition described later, an unnecessary stack is released (arrow 21).
The state of the task when the stack is released is shown in (b). When the task processing is resumed, the stack is reallocated (arrow 22). The state of the task at this time is shown in (c). In this way, when the task is not executed for a long time, the stack is released and the memory usage efficiency is improved. Note that the stack release / reallocation processing at this time is performed by the operating system. Further, regarding the task whose stack is released, the information is recorded in the task control block 23.

Next, the release and reallocation of the stack, the trigger for releasing the stack, and the restart of the task will be specifically described. (1) Release of stack and reallocation Figure 2 shows the task status when the task enters the stable state. FIG. 2 shows various task states that can be taken depending on the state of valid data. (A) is a case where there is no valid data on the stack, and the stack can be released immediately when the task enters the stable state. The case (B-1) has valid data on the task, and the valid data on the stack in the stable state is known at the time of program development and can be explicitly controlled on the program. (B-
2) is a case where the task has valid data and the valid data on the stack in the stable state depends on the execution status.
In this case, the valid data cannot be explicitly controlled on the program because the compiler includes work variables and the like allocated to the stack. However, the area of valid data can be known by the stack pointer when the task enters the stable state.

In the case of (B-1), the valid data can be treated in the same manner as (A) by allocating the valid data to a valid data area 31 different from the stack. This valid data is assigned when the task is created. In that case, the address of the valid data area 31 is recorded in the task control block 32. In the case of (B-2), as shown in FIG.
When the task in the state of (a) becomes a stable state (long-term processing suspension), the effective data is allocated to the stack (arrow 41) and saved in the effective data area 42 (arrow 43),
The stack is released (arrow 44) to enter the state of (b).
However, if the effective data area is not sufficiently small compared to the size of the stack, the overhead of program execution increases. When the task is restarted from the stable state (b) of the task, the stack is reallocated (arrow 45) and the valid data is restored from the valid data area (42) onto the stack (arrow 46). The unnecessary valid data area is released (arrow 47) or left allocated in preparation for the next save operation. In the latter case, the valid data area is released when the task is deleted. Whether or not the valid data is saved and the address of the valid data area are recorded in the task control block area (reference numerals 48 and 32).

(B-2) is further divided into the following two methods. (B-2-1) In the actual memory system, valid data is saved because valid data does not include data that depends on the memory area allocated to the original stack.
It is a condition that allows the stack to be released and reallocated. This is because the address of the memory area of the stack that is reallocated when the task is restarted is not always the same as the address of the memory area of the original stack. Figure 4
Will be explained. It is assumed that the stack 54 of a task is released after the valid data on it is saved, and then the stack is reallocated (55) to restore the valid data. The areas of the stack 54 and the stack 55 are normally allocated to memory areas having different addresses. Data 52 of the same stack on the original stack 54
It is assumed that there is data 51 having an address of. After valid data recovery, the data of 51 is copied to 56. Further, the data of 52 is copied to 53. Therefore,
The data 56 should have the address of the data of 53, but it remains the address of the data of 52 because it has just copied the original valid data. The stack area 54 is
Since it may have already been used for other purposes and the correct processing cannot be continued as it is, if the valid data contains data that depends on the memory area allocated to the original stack, the stack will be It cannot be released or reallocated.

(B-2-2) A system having a logical address translation mechanism for each page (reference: Nippon Motorola,
In the "MC68030 User's Manual", as shown in FIG. 5, the physical memory 61 for stack is allocated in page units (arrow 62), only the physical memory is released when releasing the stack (arrow 63), and the original stack is resumed when resuming the task. The physical memory is allocated to the same logical address (64) as in (arrow 65). For a task for which valid data on the stack has been saved, its information and the address of the valid data area are recorded in the task control block. In the system using the logical address translation mechanism, the logical address of the stack and the allocation status of the physical memory are recorded in the task control block. In the case of (B-1), the valid data saving area is allocated at the time of task creation, or
One of the methods of allocating when releasing the stack can be used.

(2) Trigger of stack release If the stack is released immediately when the stack becomes free, stack release / reallocation becomes more frequent when the stable state of the task is short, resulting in an overhead of execution time. Increase. Therefore, the task that can release the stack is obtained by the following method, the stack is released, and the stack area for the newly created task is secured. (B-
In the case of 2), the range of valid data on the stack can be obtained by the stack pointer. -The operating system stores the task that can release the stack (called a suspended task). -The stack is released before the stack area runs out (is used up) because it meets the real-time processing requirements. -When the usable stack area becomes less than the specified value, an appropriate task is selected from among suspended tasks by an algorithm according to the operating conditions of the system. Any known algorithm may be used as this algorithm, for example, an LRU method often used in a virtual memory method, or a method of selecting a task with the shortest interruption time among tasks suspended for a certain period or longer. The reason for setting the condition that it is suspended for a certain period of time is as follows.
This is to prevent selecting a task whose interruption time is extremely short. In real-time processing, there are short-term tasks such as waiting for I / O completion and relatively long-term tasks such as waiting for external events. If the application notifies the operating system that it will be suspended for a long period of time, the operating system only needs to release the stack of this long-term suspended task, which simplifies the selection of the task that releases the stack. To be done.

(3) Resumption of task FIG. 6 shows a flowchart for resuming a task. In FIG. 6, the task restart processing is started (step 71).
Then, the stack allocation information of the task control block is checked to determine whether or not stack allocation has been completed (step 72). If the stack remains allocated, the task is resumed according to the normal procedure (step 7).
6). If the result of determination in step 72 is that the stack has not been allocated (if the stack has been released), the reallocation of the stack is performed (step 73). And
It is determined whether or not there is a valid data save area (step 74). If there is a valid data saving area, the data is returned to the stack (step 75). The above (B-2-2)
In the case of, that is, in the case of having a logical address translation mechanism in page units, the address translation table is set so that the logical address becomes the same as the original stack.

An example in which the present invention is applied to a parallel object-oriented system is shown in FIG. 7 (reference document: Maruyama, Kubota "Method of constructing exchange program by object orientation", IEICE Transactions, J74-BI, No. 10 19
91). As shown in FIG. 7, an object is defined by an instance variable indicating the state of the object and a method (not shown) indicating an operation on the object.
Operates in parallel. The object instance 81 is
Parallel control mechanism 82 corresponding to task control, object method execution stack 83, and instance variable area 8
It consists of 4. The instance variable area 84 is an area containing data unique to the object, and always contains valid data while the object exists.

An object receives a message sent from another object and activates the corresponding method. There is no need to wait for a message during method execution. At this time, the valid data of this object is only instance variables unless the method is being executed (waiting for message reception). Therefore, the above method (B-
According to 1), the stack can be dynamically released.
Waiting for an object to receive a message corresponds to the stable state (long-term suspension) of the task described above.

As described above, in the embodiment of the present invention,
To reduce the amount of memory required without using an external storage device to satisfy real-time processing requirements, and not to complicate the program structure, multiple processing is realized by a task using a real-time operating system. Frequent deletion of tasks / in order not to complicate the program structure
I try to avoid regeneration. In this case, the memory save recovery process is performed by the operating system, and the application program is not changed in principle.

[0022]

According to the present invention, in a multi-processing system, when the processing of a task is interrupted for a predetermined period, the area excluding valid data is temporarily released and the required memory is reallocated when the processing is restarted. Because I chose
Memory usage efficiency is greatly improved.

[Brief description of drawings]

FIG. 1 is a diagram showing stack release and reallocation.

FIG. 2 is a diagram showing valid data on a stack.

FIG. 3 is a diagram showing saving and recovery of valid data on a stack.

FIG. 4 is a diagram showing conditions of stack release and reallocation.

FIG. 5 is a diagram showing stack release and reallocation when a logical address is used.

FIG. 6 is a diagram showing a processing procedure for task restart.

FIG. 7 is a diagram showing objects operating in parallel.

FIG. 8 is a state transition diagram of a task.

FIG. 9 is a diagram showing the structure of a task.

[Explanation of symbols]

1 Transition to attach task and put task control block in ready queue 2 Transition to move ready task to active state 3 Transition to move active task to wait state 4 Transition to move ready task to ready state 5 Transition in which active task moves to ready state 6 Transition in which active task finishes processing and releases resources 11 Task 12 Task control block (TCB) 13 Stack 14 Push operation 15 Pop operation 16 Effective data on stack 17 Stack pointer instruction 18 Stack address field 19 Stack pointer field 21 Stack release 22 Stack reallocation 23 Stack allocation status field 31 Effective data (save) area (allocation at task creation) 32 Effective data area address Field 41 Effective data area allocation 42 Effective data (save) area (allocation at stack release) 43 Effective data save (copy from stack to effective data area) 44 Stack release 45 Stack reallocation 46 Recovery of effective data (effective data area) To stack) 47 Release valid data area 48 Saved data status field 51 Data with address of data on same stack (before stack release) 52 Data pointed to by other data on same stack (before stack release) ) 53 data to be pointed to by other data on the same stack (after stack reallocation) 54 stack before release 55 reallocated stack 56 data having address of data on the same stack (after stack reallocation) 61 stack Physical memory (page) 62 physical memory allocation 63 physical memory release 64 same logical reallocation 81 object instance 82 object parallel operation mechanism 83 object method invocation stack 84 instance variable region of physical memory for allocation 65 stack stack to the address

Claims (1)

[Claims] 1. A memory management method in a multi-processing system for operating a plurality of tasks in a multiplexed manner, wherein each task is dynamically allocated to the execution program as needed and managed last in first out. When it is detected that the task is not executed for a predetermined period of time, the area except the valid data in the stack allocated to the task is temporarily released, and the task A memory management method in a multi-processing system, wherein required memory is reallocated when restarted.