JP2001101070A - Memory management method and memory management device - Google Patents

Abstract

(57) [Problem] Although a conventional memory management method and memory management device have a problem that garbage collection cannot be performed efficiently, the present invention has an effect on execution of real-time processing. Provided are a memory management method and a memory management device capable of efficiently performing garbage collection without using the memory management method. A central processing unit (1) intermittently executes a program stored in a program memory (2), and uses a heap memory (4) or a variable in a static variable storage unit (7) as a reference count number. A memory management method and a memory management device for performing a garbage collection process of storing a memory area having a reference count of 0 each time the program processing is completed and stored in a memory 4 in association with a memory area. .

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a memory management method and a memory management device for a real-time system for processing real-time data, and more particularly to improving the efficiency of garbage collection.

[0002]

2. Description of the Related Art A conventional memory management device will be described. Conventionally, various methods have been considered as a method of returning an allocated memory area to an unused state when the memory area is no longer used, that is, a garbage collection method. For example, "Uniprocessor Garbage C
ollection Techniques ", Paul R., Wilson, LNCS 637
Introduces a number of garbage collection methods.

[0003] Conventionally, as a garbage collection method for improving the efficiency in hard real-time processing, there is a read barrier method in which a mark-and-sweep garbage collection system is applied to a real-time system. Here, the garbage collection system of the mark-and-sweep method is to detect a memory area that is being used in advance to identify a memory area that is no longer used, and then use an unused memory area other than the used memory area. Collect as a memory area. In the garbage collection method based on the read barrier method, garbage collection processing and program processing are operated in parallel. Thus, it is possible to prevent the processing of the program from being stopped for a long time as in the case of the simple mark-and-sweep method, and the present invention can be applied to a real-time system.

However, also in this case, since the mark-and-sweep method is basically used, the memory area that is no longer used is not collected as an unused memory area until the garbage collection is completed. . For this reason, if the garbage collection is delayed, there is a possibility that the memory area becomes insufficient during the processing of the program executed in parallel. For example, if the garbage collection is at most 100
If the program processing is a task that is started at a cycle of 10 milliseconds and the program area is guaranteed to finish in milliseconds, the memory area that is used once by the program and is no longer used will be at least 100 milliseconds. It will not be collected unless seconds elapse. Therefore, unless a memory area at least ten times as large as the actually required memory is prepared, the program processing is hindered.

In addition, it is not always possible to recover all the memory areas that are no longer used during garbage collection, and it is difficult to guarantee that garbage collection is completed in a predetermined time. Therefore, it is necessary to prepare a large amount of memory compared to the required amount of memory.

On the other hand, as another method for realizing garbage collection, there is a memory management method of a reference counting system. The traditional memory management method using reference counting is
A reference counter is associated with each memory area, and each time reference to a required object is started / referenced, the reference counter of the memory area storing the object is increased or decreased. This reference counting garbage collection process is complicated and inefficient.
In order to improve this, a delayed reference counting method has been proposed (see “An Efficient Incremental Automat
ic Garbage Collector ", Peter Deutsch and Daniel
G. Bobrow, Communications of ACM 1976 Vol 19. No.
9).

In this delayed reference counting method, the reference count is increased or decreased only at the time of assignment to a variable located in a static area or a heap area, so that the opportunity of increasing or decreasing the reference count is reduced and further continued. If the memory becomes insufficient while the processing is continued, the program processing is interrupted, the stack area is scanned, the number of references from the reference variables (pointer variables) stored in the stack area is checked, and the reference count is performed. Is determined to be a memory area whose reference count is "0" and a memory area whose reference count is "0", and the memory area whose reference count is "0" is set as unused.

[0008]

As described above, the above-mentioned conventional memory management method has a problem that garbage collection cannot be efficiently performed without affecting real-time processing.

SUMMARY OF THE INVENTION The present invention has been made in view of the above circumstances, and has as its object to provide a memory management method and a memory management device capable of efficiently executing garbage collection processing without affecting real-time processing. I do.

[0010]

According to the first aspect of the present invention, a memory area is allocated to each object for managing a memory for a program which terminates processing in a predetermined time. A memory management method for generating a new object, selecting an unused one of the memory areas and storing the object in the selected unused memory area;
Of pointer variables referring to objects stored in the memory area, managing the number of pointer variables stored in the heap memory or the static variable area as a reference count in association with the memory area;
When the program is completed, a reference count associated with each memory area is checked, and if the reference count is 0, the corresponding memory area is set as unused.

As a result, the memory area whose reference count has become 0 can be set as an unused memory area while the program is terminated and no variable stored in the stack exists, without affecting real-time processing. Garbage collection can be performed efficiently.

Further, before the memory area whose reference count is 0 is unused, the inside of the object stored in the memory area is searched, and the memory area associated with the memory area referenced by the object is searched. Preferably, the reference count is decremented. Thereby, the reference count can be reliably increased or decreased.

According to a fifth aspect of the present invention, there is provided a memory management system for allocating a memory area for each object and managing a memory for a program which terminates processing in a predetermined time. An apparatus for generating a new object, selecting an unused one of the memory areas, storing the object in the selected unused memory area, and storing the object in the memory area. Means for managing the number of pointer variables stored in the heap memory or the static variable area as a reference count in association with the memory area, and The reference count associated with the memory area is checked. If the reference count is 0, the corresponding memory area is determined to be unused. It is characterized in that it comprises means for constant, the.

Thus, the memory area whose reference count becomes 0 can be set as an unused memory area while the program is terminated and no variable stored in the stack exists, without affecting the real-time processing. Garbage collection can be performed efficiently.

Further, it is preferable that the program is an interrupt processing program. As a result, unused memory can be reliably collected when the interrupt processing program ends, and the interrupt processing is not affected.

Further, it is preferable that the program is a program that is executed periodically. As a result, even if the program is repeatedly started, the unused memory is surely collected, and the free space of the memory is not squeezed, and the processing of the program executed periodically is affected. There is no.

[0017]

Embodiments of the present invention will be described with reference to the drawings. FIG. 1 is a configuration block diagram of a memory management device according to an embodiment of the present invention. As shown in FIG. 1, the memory management device according to the present embodiment includes a central processing unit 1, a program memory 2, a timer unit 3, a heap memory 4, a table storage unit 5, a stack memory 6,
And a static variable storage unit 7.
Each unit is mutually connected via a system bus BUS.

The program memory 2 stores a program to be processed by the central processing unit 1. The timer unit 3
An interrupt signal is output at regular intervals. The central processing unit 1 receives an interrupt signal from the timer unit 3 at predetermined time intervals via the system bus BUS, and executes a program stored in the program memory 2. The central processing unit 1 includes a means for selecting an unused memory area when generating a new object and storing the object, and a means for associating a reference count with the memory area. This corresponds to a means for checking the reference count associated with each memory area at the end of the program, and setting the corresponding memory area as unused if the reference count is 0.

The heap memory 4 manages a memory used by the central processing unit 1 as a heap area. The heap memory 4 is divided into a plurality of areas, and the central processing unit 1
Assigned as needed. Each of the memory areas stored in the heap memory 4 is associated with the number of pointer variables (reference count; RC) that refers to the memory area. What is characteristic in the present invention is that the reference count indicates the number of references from the pointer variables stored in the heap memory 4 or the static variable storage unit 7. That is, the number of references from the pointer variables stored in the stack memory 6 is not counted.

The table storage unit 5 is a memory for managing a table area, and includes an allocatable memory area table AM.
T, a zero count table ZCT, and a multi-reference table MRT (hereinafter collectively referred to as a “table group”). Here, the assignable memory area table AMT refers to an unused memory area among a plurality of memory areas stored in the heap memory 4.
Further, the zero count table ZCT refers to a memory area having a reference count of 0 among the memory areas in use stored in the heap memory 4. Furthermore, the multi-reference table MRT refers to a memory area in use stored in the heap memory 4 and having a reference count of 1 or more. The stack memory 6 stores variables used only during processing of the program, such as local variables. The static variable storage 7 stores static variables. Here, “static” means that the contents are retained even after the program ends.

Here, the contents of the processing of the central processing unit 1 will be specifically described with reference to FIGS. Figure 2
9 is an explanatory diagram showing the contents of the memory while the central processing unit 1 is processing the program, and FIGS. 10 to 13 are flowcharts showing the processing of the central processing unit 1.

First, the contents of the table storage unit 5, the heap memory 4, the stack memory 6, and the static variable storage unit 7 when the program has never been executed are as shown in FIG. ing. As shown in FIG.
Allocatable memory table AMT of table storage unit 5
Indicates (refers to) all the allocable memory (unused area) stored in the heap memory 4.
I have. In a state where the program shown in FIG. 2 has never been executed, all the memory areas MEM1 to MEMn are unused, so the allocatable memory table AMT refers to all the memory areas. In FIG. 2, since each memory area has not been initialized, the reference count RC has an indefinite value (shown as “?”). Therefore, the zero-count table ZCT and the multi-reference table MRT have different values. Has nothing registered.

The central processing unit 1 performs real-time processing while intermittently executing a specific program. In this program, a “memory area allocation” process (allocation process) and a “memory area Basically, a process of storing a reference to a pointer (pointer setting process) and a process of releasing a reference from a variable to a memory area (pointer release process) are performed. In addition, the central processing unit 1 performs a process of “collecting a memory area” (a garbage collection process).

Hereinafter, the assignment processing of the central processing unit 1 will be described with reference to FIG. When starting the allocation processing, the central processing unit 1 allocates the assignable memory table AM
Search and select an unused memory area from T (S1
1) The selected memory area is removed from the assignable memory table AMT (S12), and the reference count RC of the selected memory area is initialized to “0” (S13).
Then, the central processing unit 1 registers the selected memory area in the zero count table ZCT (S14), and ends the processing. Then, the allocated and initialized memory area is referred to from the zero count table ZCT.

The pointer setting process of the central processing unit 1 will be described with reference to FIG. In the following description, substituting the memory area A for the variable X means setting a pointer (a memory address or an identifier (ID) for reference) referring to the memory area A to the variable X. When the pointer setting process is started, the central processing unit 1 determines whether or not the variable X to be set is stored in the heap memory 4 or the static variable storage unit 7 (S
21) The variable X is the heap memory 4 or the static variable storage unit 7
(If Yes), it is determined whether or not the reference count RC of the memory area A to be set is the initial value “0” (S22). Here, if the reference count RC of the memory area A to be set is the initial value “0” (if Yes), the memory area is removed from the zero count table ZCT (S23), and the multi-reference table MRT (S24). Then, the reference count RC of the memory area A is incremented (S25), and the pointer to the memory area A is set to the variable X
And set (S26), and the process ends. Also,
In the process S22, if the reference count RC of the memory area A to be set is not the initial value “0” (if No), the process proceeds to the process S25 to continue the process. Further, in step S21, if the variable X to be set is not stored in the heap memory 4 or the static variable storage unit 7 (if No), the process proceeds to step S26 to perform the processing.

Further, pointer release processing of the central processing unit 1 will be described with reference to FIG. Central processing unit 1
When the pointer release process is started, it is determined whether or not the variable X to be released is stored in the heap memory 4 or the static variable storage unit 7 (S31). If it is stored in the memory 4 or the static variable storage unit 7 (Yes), the reference count RC of the memory area A referred to by the variable X is decremented (S3).
2). Then, the central processing unit 1 determines whether or not the reference count of the memory area A has become equal to the initial value “0”, that is, whether or not there is no pointer variable that refers to the memory area A (S33). If there is no pointer variable referring to the memory area A and it becomes equal to the initial value “0” (if Yes), the memory area A
From the multi-reference table MRT (S
34), the memory area is registered in the zero count table ZCT (S35), and the process ends. In the process S33, the pointer variable referring to the memory area A still remains in the heap memory 4 or the static variable storage unit 7,
If the reference count RC of the memory area A is not equal to the initial value “0” (if No), the processing is terminated.
Further, in the process S31, the variable X is stored in the heap memory 4
Otherwise, if it is not stored in the static variable storage unit 7 (if No), the processing is terminated as it is.

The garbage collection process of the central processing unit 1 will be described with reference to FIG. When starting the garbage collection process, the central processing unit 1 first
The zero count table ZCT is scanned, and it is determined whether or not the processing of step S42 and subsequent steps described below has been completed for all the memory areas MEMi registered in the zero count table ZCT (S41), and the processing has been completed. If not (No), it is determined whether or not the processing after step S43 has been completed for all variables HVi in the specific memory area MEMi (S42). If the processing is not completed (if No), it is determined whether or not the specific variable HVi refers to another memory area (S4).
3) If it is referred to (if Yes), the pointer release processing described above is performed, and the memory area X is obtained from the variable HVi.
Is canceled (S44), and the process returns to step S41 to continue the process. If the variable HVi does not refer to another memory area in the process S43 (if No), the process returns to the process S41 to continue the process. Further, in step S42, if the process has been completed for the variable HVi in the memory area MEMi (if Yes), the process returns to step S41 to continue the process. Further, in step S41, if the processing has been completed for all the memory areas registered in the zero count table ZCT (if Yes), the processing ends as it is.

Hereinafter, changes in the contents of the memory when each processing is performed in the central processing unit 1 will be described. First, when in the state of FIG. 2, the central processing unit 1 allocates the memory area MEM1 to the heap memory 4 and
For the local variable LCV-X located above, the memory area MEM
The case where the pointer to 1 is set will be described. FIG. 3 shows a state after the pointer is set to the local variable LCV-X on the stack memory 6. The transition from the state shown in FIG. 2 to the state shown in FIG. 3 is performed by an area allocation process and a pointer setting process. First, a memory area that can be allocated on the heap memory 4 is searched by the area allocation processing.
In FIG. 2, for example, since the memory area MEM1 is unused and can be allocated, MEM1 is selected, and after predetermined processing,
MEM1 is initialized. As a result, the memory area MEM1 is removed from the allocatable memory table AMT and registered in the zero count table ZCT. Then, the pointer is set to the variable LCV-X by the pointer setting process. Since the variable LCV-X at the substitution destination is a local variable and is stored in the stack memory 6, the pointer corresponding to the memory area MEM1 is referred to. The count RC is not incremented, and the pointer referring to the memory area LCV-X is set to the local variable LCV-X
It is only stored in

Further, in the state of FIG. 3, the memory area MEM2 is allocated and the memory area MEM2 is stored in the static variable STV-A.
The case where the pointer to 2 is assigned will be described. FIG. 4 shows a state after the assignment to the static variable STV-A.
The transition from FIG. 3 to FIG. 4, that is, the assignment of the memory area MEM2 to the static variable STV-A is achieved by the area allocation processing and the pointer setting processing. First, an unused memory area MEM2 that can be allocated is allocated by the area allocation processing. Then, this memory area MEM2 is removed from the allocatable memory table AMT and registered in the zero count table ZCT. Subsequently, the assignment is performed by the pointer setting process. In this case, the assignment destination variable STV-A is a static variable stored in the static variable storage unit 7 and the reference count of the memory area immediately after the assignment. Since RC is equal to the initial value, the memory area MEM2 is removed from the zero count table ZCT and the multi-reference table MRT
Registered in. Further, reference count RC of memory area MEM2
Is incremented to “1”.

Further, when in the state of FIG. 4, the static variable ST
A case where the memory area MEM2 referred to by the VA is also referred to by the variable HV1 located in the object in the memory area MEM1 will be described. FIG. 5 shows a state after the pointer to the memory area MEM1 is assigned to the variable HV1. This is achieved by a pointer setting process for the variable HV1. In this case, since the variable HV1 exists in the object in the memory area MEM1, that is, is located in the heap memory 4, the reference count RC of the memory area MEM2 is incremented, and RC becomes “2”, and the memory area MEM2 is identified. Is stored in the variable HV1.

Further, when in the state of FIG. 5, the static variable ST
A case where the VA no longer references the memory area MEM2 will be described. FIG. 6 shows a state after the static variable STV-A no longer references the memory area MEM2. The transition from FIG. 5 to FIG. 6, that is, the memory area MEM2 is a static variable STV-A
To be no longer referenced by the static variable STV-A
This is realized by pointer release processing for. In this case, the reference count RC of the memory area MEM2 is decremented. However, since the value of the decremented reference count RC does not become the initial value “0”, the pointer release processing ends as it is.

Next, the case where the program ends when the contents of the memory are in the state shown in FIG. 7 will be described. In the state shown in FIG. 7, the first memory area MEM1 is referred to from the variable LCV-X stored in the stack
Is referred to by the variable HV1 existing in the object in the first memory area MEM1, and the third memory area MEM3 is referred to by the variable STV-B in the static variable storage unit 7. Therefore, the first memory area MEM1 has been initialized, but is not referred to from the heap memory 4 (that is, an object of another memory area) or the static variable storage unit 7, so that the value of the reference count RC is Is the initial value "0"
And it is referred from the zero count table ZCT. On the other hand, the second memory area MEM2 is
The value of the reference count RC is “1” because it is referenced from a variable in the heap memory 4 and is referenced from the multi-reference table MRT. Similarly,
Since the third memory area MEM3 is referenced from a variable in the static variable storage unit 7, the value of the reference count RC is “1”, and the multi-reference table MRT
Is referenced from.

Generally, when the program ends, all the variables stored in the stack memory 6 are cleared. Therefore, as shown in FIG. 8, the contents of the memory after the program ends are such that the local variable LCV-X disappears. It will be like that. At the end of the program, the operation of releasing the reference from the variable LCV-X in the stack memory 6 to the first memory area MEM1 is performed by pointer release processing. In this case, the variable LCV-X Since it is in the memory 6, there is no change in the contents of the table.

FIG. 9 is an explanatory diagram showing a state after memory recovery is performed in the state of FIG. The transition from FIG. 8 to FIG. 9 is achieved by collecting the memory area by the garbage collection process. That is, first, the first memory area MEM1 registered in the zero count table ZCT is selected and examined.
M1 is a memory area that can be collected because it is not referenced from variables already stored in memory other than the stack and is unused. However, if the first memory area MEM1 is released and unused, the second memory area MEM2 is deleted even though the pointer variable pointing to the second memory area MEM2 also disappears.
The process of adjusting the reference count RC corresponding to MEM2 is not performed. Therefore, before the first memory area MEM1 is collected, it is necessary to cancel all references from variables located in the first memory area MEM1 to other memory areas. In this case, it is necessary to cancel the reference from the variable HV1 to the memory area MEM2.

Then, as a result of performing the process of releasing the variable HV1, the second memory area MEM2 is removed from the multi-reference table MRT and the zero count table ZCT
Registered to. Then, the second memory area MEM2 is also a collection target.

Thus, the first memory area MEM1
Then, the second memory area MEM2 is collected, removed from the zero count table ZCT, and registered in the allocatable memory table AMT as an unused memory area. Here, only the third memory area MEM3 referred to by the static variable STV-B remains registered in the multi-reference table MRT, but all other memory areas are collected and unused. The memory area is registered in the allocatable memory area AMT. In addition,
In the recovered memory area MEMi, the reference count is equal to the initial value, and does not need to be initialized at the next allocation.

Next, the operation of the memory management device according to the present embodiment will be described more specifically by taking a case where a program for performing a simulation is executed by the central processing unit 1 as an example. In the following description, a case where the video interface 8 is connected via a system bus BUS as shown in FIG. 14 will be described as an example. The video interface 8 includes a video memory 11 and outputs a vertical synchronization signal as an interrupt signal to the central processing unit 1 via a system bus BUS. Also, here
When receiving the interrupt signal according to the program stored in the program memory 2, the central processing unit 1
Data to be written to the video memory 11 is generated, and a process of writing to the video memory 11 is performed. The video memory 1 in the video interface 8 is synchronized with the vertical synchronizing signal.
The central processing unit 1 should display the next frame while the screen is being scanned, in order to update the content of No. 1 as the simulation progresses and to display a more realistic moving image. It is necessary to complete the creation of the update data and write the update data to the video memory 11 within the vertical blanking period. That is, here, the central processing unit 1 starts the screen scanning and starts the processing, and completes the processing by the end of the scanning, and receives the input of the vertical synchronization signal as the interrupt signal. The second process, which starts and ends the process within the vertical flyback period, is performed alternately and intermittently.
In the first and second processes, in the process of generating an object and setting and releasing a pointer, it is assumed that the area allocation process, the pointer setting process, and the pointer releasing process described above are used. .

Then, the central processing unit 1 performs the above-mentioned garbage collection process every time the first and second processes are completed. Thus, in the first process for creating the update data of the video memory, the completion of the process is detected by the input of the interrupt signal, and the unnecessary memory area can be collected. In addition, the timer unit 3 is not necessarily a vertical synchronization signal. For example, in order to detect the end of the second process, the timer unit 3 needs to pay attention to the fact that the second process is a process that is periodically executed. The CPU 3 may output an interrupt signal synchronized with the completion of the execution of the process, and the central processing unit 1 may perform the garbage collection process in accordance with the interrupt issued from the timer unit 3.

Further, if the apparatus is configured to start a program by an interrupt signal, it is not limited to a simulation apparatus, but may be an apparatus that performs a numerical operation at regular intervals, such as a function generating process of a numerical control device or the like. Can also be applied.

Here, the cycle of the interrupt need not always be constant. For example, a packet that arrives irregularly, such as a communication packet, is processed by an interrupt program within a fixed time so as to prepare for the arrival of the next packet. You may.

Further, the program does not necessarily have to be started by an interrupt signal, but may be started at regular intervals, for example. In this case, as shown in FIG. 15, the central processing unit 1 waits for a timing until a certain time has elapsed (S51), starts a program created so as to end within a certain period (S52), and executes this program. Garbage collection processing may be performed after the end of the processing, and the memory may be collected (S53).

Here, the process S51 of waiting for timing until a predetermined time elapses can use a method called polling for monitoring the value of the vertical synchronizing signal or the timer unit 3, or the timing provided by the operating system. It can also be realized by a system call.

As described above, a characteristic of the present invention is that, for example, in real-time processing, a program is completed in a relatively short period of time and all variables stored in the stack memory 6 are erased. Then, paying attention to the fact that the memory area in the heap memory 4 cannot be referred to from the stack memory 6, the garbage collection process is performed at the timing of the end of the program. This eliminates the need to search the stack memory 6 at the time of garbage collection, and eliminates the need to count the number of references from the stack memory 6 as a reference count. Therefore, garbage collection can be performed efficiently without using special hardware. In particular, the release of a memory area referenced by a variable in a garbage (unused) memory area can be performed by a program. Since the processing is performed after the completion, the execution of the original program is prioritized over the garbage collection processing, and the execution of the original program is not affected. Further, since the memory is collected immediately upon completion of the program, a memory area required for executing the program once may be prepared, and the required memory capacity can be reduced.

[0044]

According to the present invention, garbage collection can be performed efficiently without affecting the execution of real-time processing by performing garbage collection at the end of the program.

Further, since the memory is recovered immediately upon completion of the program, a memory area required for executing the program once may be prepared, and the required memory capacity can be reduced.

[Brief description of the drawings]

FIG. 1 is a configuration block diagram of a memory management device according to an embodiment of the present invention.

FIG. 2 is an explanatory diagram showing contents of a memory while a central processing unit 1 is processing a program.

FIG. 3 is an explanatory diagram showing the contents of a memory while a central processing unit 1 is processing a program.

FIG. 4 is an explanatory diagram showing the contents of a memory while the central processing unit 1 is processing a program.

FIG. 5 is an explanatory diagram showing the contents of a memory while the central processing unit 1 is processing a program.

FIG. 6 is an explanatory diagram showing the contents of a memory while the central processing unit 1 is processing a program.

FIG. 7 is an explanatory diagram showing the contents of a memory while the central processing unit 1 is processing a program.

FIG. 8 is an explanatory diagram showing the contents of a memory while the central processing unit 1 is processing a program.

FIG. 9 is an explanatory diagram showing the contents of a memory while the central processing unit 1 is processing a program.

FIG. 10 is a flowchart illustrating the processing of the central processing unit 1;

FIG. 11 is a flowchart illustrating a process of the central processing unit 1;

FIG. 12 is a flowchart illustrating a process of the central processing unit 1;

FIG. 13 is a flowchart illustrating the processing of the central processing unit 1.

FIG. 14 is another configuration block diagram of the memory management device according to the embodiment of the present invention.

FIG. 15 is a flowchart illustrating the processing of the central processing unit 1.

[Explanation of symbols]

1 Central processing unit, 2 program memory, 3 timer unit, 4 heap memory, 5 table storage unit, 6 stack memory, 7 static variable storage unit, 8 video interface, 11 video memory.

Continued on the front page (72) Inventor Masato Ryoki 5-25-25 Shimokoguchi, Oguchi-machi, Niwa-gun, Aichi Prefecture Inside the Oguchi Plant of Okuma Co., Ltd. F term (reference) 5B060 AA10 AA14 AC11 5B098 GD00 GD03 GD22

Claims (7)

[Claims] 1. A memory management method for managing a memory by allocating a memory area for each object for a program that terminates processing in a predetermined time, wherein a new object is generated when a new object is generated. Selecting an unused one of them, storing the object in the selected unused memory area, and storing, in a heap memory or a static variable area, a pointer variable pointing to the object stored in the memory area. Managing the number of pointer variables as a reference count in association with the memory area; and examining the reference counts associated with the respective memory areas when the program ends, and determining that the reference count is 0. Setting the corresponding memory area as unused. Method. 2. The memory management method according to claim 1, further comprising: when the program ends, searching inside an object stored in a memory area corresponding to a reference count that is zero. Decrementing a reference count associated with a memory area referred to from the memory management method. 3. The memory management method according to claim 1, wherein the program is an interrupt processing program. 4. The memory management method according to claim 1, wherein said program is executed periodically. 5. A memory management device which manages a memory by allocating a memory area for each object for a program which terminates processing in a predetermined time, wherein a new object is generated when a new object is generated. Means for selecting an unused one and storing the object in the selected unused memory area; and a pointer variable pointing to the object stored in the memory area, which is stored in the heap memory or the static variable area. Means for managing the number of pointer variables as reference counts in association with the corresponding memory area, and examining the reference counts associated with the respective memory areas when the program ends, and if the reference count is 0 And a means for setting a corresponding memory area as unused. 6. The memory management device according to claim 5, wherein the program is an interrupt processing program. 7. The memory management device according to claim 5, wherein the program is executed periodically.