JPH11338761A - Dynamic memory managing mechanism - Google Patents

Abstract

PROBLEM TO BE SOLVED: To permit a garbage collecting process which can be placed continuously in operation for a long period and is simple and efficient by specifying a releasing method for an object area when garbage collecting processes by a reference counter system and another system are carried out in combination. SOLUTION: Each reference counter 11 of each object area 10 increases and decreases in the value representing the number of a pointer 12 referring to the object area 10. A garbage collecting means 5 when the garbage collecting processes by the reference counter system and another system are performed in combination releases only a corresponding 1st object area 10 which is released when the value of the reference counter 11 reaches 0. A 2nd object area 10 that the pointer 12 is referring to in the 1st object area does not conduct the updating process of the value of the reference counter 11 and the releasing process of the object area 10 accompanying it.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to an improvement of a memory management mechanism in a computer system, and more particularly to an improvement of a dynamic memory management mechanism having automatic garbage collection means for a memory area.

[0002]

2. Description of the Related Art For example, as shown in the description of the prior art in "Method and System for Improving Data Storage Efficiency" described in JP-A-63-253445, automatic garbage of memory in a dynamic memory management mechanism is disclosed. Collection processing (hereinafter, referred to as “garbage collection processing” or “GC processing”) is a field that has been studied for many years, and technical development including many related branches is being performed.

[0003] The purpose of the garbage collection process is to determine a storage area that a program operating in a computer system acquires and uses from a dynamic memory management mechanism during the operation.
It is an object of the present invention to automatically recover and reuse a storage area that is no longer used by a program without explicitly opening the storage area, thereby enabling effective use of the storage area.

The garbage collection process is conceptually composed of two stages. In the first stage, a distinction is made between storage areas used by the program ("live") and storage areas not used by the program ("garbage"). Then, in the next stage, "garbage" is collected and made available again. In the garbage collection process, whether the storage area in the dynamic memory management mechanism is “live” or “garbage” is determined by the reachability of the storage area from the program. First, a storage area that can be referred to by a program based on data outside the dynamic memory management mechanism is a “live” storage area. Next, a storage area that can be referenced by a program based on data held in the “live” storage area is also defined as a “live” storage area. It is defined recursively. The “garbage” storage area is a “non-live” storage area, and cannot be referenced by a program using either data outside the dynamic memory management mechanism or data held by the “live” storage area. Defined as an area.

FIG. 35 is an explanatory diagram showing the distinction between "live" storage areas and "garbage" in the garbage collection process. The dynamic memory management mechanism 1 includes a heap area 2 which is a part of a memory area of a computer system, and one or a plurality of object areas 10 which are storage areas used by programs exist in the heap area 2. . The pointer 12 is data used by the program to refer to the object area 10. In FIG. 35, the object areas A, B, X, and Y each have one or two pointers
And two pointers Rp1 and Rp2 exist outside the dynamic memory management mechanism 1.

In FIG. 35, an object area A and an object area D respectively correspond to the dynamic memory management mechanism 1
Since the program can be referred to using the pointers Rp1 and Rp2 located outside of the object area, both are regarded as the "living" object area 10. The object areas B and C that can be referenced from the pointer 12 included in the “live” object area A are also “live” object areas 10. On the other hand, object areas X and Y
And Z are pointers R outside the dynamic memory management mechanism 1.
These object areas are regarded as “garbage” because they cannot be referenced from p1 or Rp2 from the program directly or via another “living” object area 10.

The difference between the various methods proposed as the garbage collection process is a difference in how to execute the above two conceptual steps. As the main conventional technologies relating to the garbage collection process, there are three basic systems, a "reference counter system", a "mark-sweep system", and a "stop-copy system". Step) and “generational”
There are two directions. Hereinafter, the related art and its problems will be described.

FIG. 36 is a configuration diagram of a first conventional example, a dynamic memory management mechanism for performing garbage collection processing by a simple "reference counter method". The dynamic memory management mechanism 1 includes a heap area 2 that is a part of a memory area of the computer system, a memory acquisition unit 3 that acquires a part of the heap area 2 as an object area 10, Memory retrieving means 4 for returning the same to the heap area 2 and reusing it, and searching for the object area 10 acquired by the memory acquiring means 3 but no longer used by the program.
And a garbage collection unit 5 that opens the heap area 2 using The heap area 2 is often a single memory area whose addresses are continuous,
Some computer systems may be composed of a plurality of memory areas.

In the heap area 2, one or more object areas 10 can exist. Each object area is a small memory area in the heap area 2 that is generated by the memory acquisition unit 3 and deleted by the memory release unit 4. Various kinds of information necessary for the operation of the program are appropriately held in the object area 10. The information held in the object area 10 largely depends on the development language and program design of the program, and may include only data necessary for the operation of the program, or may include instruction codes of the program.

Each object area 10 has a reference counter 11. This is a characteristic structure in the reference counter type garbage collection process. The reference counter 11 is a variable that holds an integer value, and the value indicates how many pointers 12 refer to the corresponding object area 10.

The pointer 12 is program data that needs to be considered when performing garbage collection processing. The pointer 12 indicates that the program is in the object area 1
This is a storage area for holding information necessary to reference 0, and exists as a CPU register of a computer, a memory area or a stack in a memory (small memory area) where a program is statically arranged, and a variable in the object area 10. I do.

Next, the operation of the conventional example will be described.
FIG. 37 is a flowchart showing an operation of acquiring an object area in the conventional example. Object area 10
In the operation of acquiring the memory area, first, a memory area of an appropriate size explicitly or implicitly designated by the program is acquired from an unused portion in the heap area 2 (P1101), and the acquired area is then stored in the object area 10 , The value of the reference counter 11 is set to 0 (P1102), and other places (data) in the acquired object area are initialized as necessary (P1103). The value of the pointer required to perform the operation is returned (P1104). Here, the procedure P1102
The value of the reference counter 11 is set to 0 because the newly created object area 10 has not been referenced by any pointer 12 yet, and the number of pointers 12 referring to the object area is 0. by.

The update of the value of the reference counter 11 is performed in synchronization with the change of the value of the pointer 12. FIG. 38 is a flowchart showing an operation of changing the value of the pointer 12 in the conventional example. Operation P12 of changing the value of the pointer 12
If the value is 0, the validity of the value held by the pointer 12 that changes the value is checked (P1201). If pointer 1
If 2 refers to the object area 10 prior to the change of the value (Yes in P1201), this change reduces the number of pointers that refer to the object area 10 of the reference destination. The value is subtracted by 1 (P1202). As a result, the reference counter 11
Is 0 (Yes in P1203), the target object area 10 is an object area 10 that is not referenced by any pointer 12, ie, “garbage”.
, The object area 10 is released.

When the object area 10 is released, the pointer for referring to one or more other object areas 10 is also lost by releasing the target object area 10, and as a result, the value of the reference counter 12 of the other object area 10 is lost. May need to be adjusted. Therefore, if the target object area 10
Has one or more pointers 12 therein (Yes in P1204), recursively returns the values of all the pointers 12 present in the object area 10 and the operation P120 of changing the values of the pointers 12. (P120), an invalid value (a value that does not refer to the object area, usually 0 to NULL) is set.
6, P1207, P1208), and thereafter, the object area 10 is released using the memory release means 4 (P120).
9).

Thereafter, first, the value of the pointer 12 is set to a new value (P1210). If the value is valid and refers to the object area (Yes in P1211),
Since the number of pointers that refer to the object area of the reference destination increases, the reference counter 11 of the object area 10
Is added by 1 (P1212), and the process ends.

If the value of the reference counter 11 does not become 0 even when the value of the reference counter 11 of the object area 10 referred to by the pointer 12 before the value is changed becomes 1 (No in P1203), the target is set as the target. Object area 1
Since 0 is still being referred to by another pointer 12 and is the object area 10 in use, the object area is not released, and a new value is immediately set in the pointer 12 (P1210). This occurs when the value of the pointer 12 before the value is changed is an invalid value (P120
The same applies to No. 1), which promptly sets a new value to the pointer 12 (P1210). If the new value set in the pointer is an invalid value (No in P1211), there is no reference counter 11 to be updated.
The process is immediately terminated without performing step 12.

FIG. 39 shows a specific operation of the conventional example.
This will be described with reference to FIGS. 40, 41, and 42.

FIG. 39 is an explanatory view showing a state before the first operation of the conventional example. In FIG. 39, a pointer Rp is a pointer 12 existing outside the heap area 2 as a CPU register of a computer, a memory area statically allocated by a program, or a variable in a stack, and refers to the first object area A. doing. Object area A
Holds a pointer Ap1 and a pointer Ap2 therein, and the pointer Ap1 stores the second object area B,
Further, the pointer Ap2 refers to the third object area C. Object area B has pointer B inside
It holds p1 and a pointer Bp2, and the pointer Bp1 refers to the object area C like the pointer Ap2, but the pointer Bp2 does not refer to any object area and holds an invalid value. The object area C does not hold the pointer 12 therein. Since the object area A is referred to only by the pointer Rp, the value of the reference counter Ac1 of the object area A is 1. Similarly, since the object area B is referred to only by the pointer Ap1, the value of the reference counter Bc1 is 1, and since the object area C is referred to by the pointer Ap2 and the pointer Bp1, its reference counter Cc
The value of 1 is 2.

In the situation shown in FIG. 39, the operation P120 of changing the pointer Rp to an invalid value is as follows. Since the value of the pointer Rp before the change is a valid value referring to the object area A, the process proceeds to P1201 and P1202. As a result of P1202, the value of the reference counter Ac1 becomes 0, so the process proceeds to Yes in P1203. Further, since the object area A includes the pointers Ap1 and Ap2 inside, the process proceeds from Yes in P1204 to P1205, and first the pointer Ap1 Is performed for P1206. In P1206, P120 is recursively executed for the pointer Ap1, whereby the value of the reference counter Bc1 of the object area B referred to by the pointer Ap1 decreases from 1 to 0 (P120 in the P120 for the pointer Ap1).
2) The reference counter Cc1 of the object area C to which the pointer Bp1 held by the object area B is referred
Is also reduced by 1 (P1 for pointer Bp1)
20, the object area B is released (P1209 in P120 for the pointer Ap1),
The value of the pointer Ap1 is set to an invalid value (P1210 in P120 for the pointer Ap1). FIG.
39 is an explanatory diagram showing a situation at this stage. FIG. 39 shows a reference counter Ac1, a reference counter Bc1, and a reference counter C with respect to FIG.
c1 is decremented by one, the object area B is released (broken line), and the pointer Ap1 and the pointer Bp1 are set to invalid values.

P for pointer Ap1 at P1206
When the execution of step 120 is completed, the processing is No in P1207,
The process proceeds to P1208, and in P1206, P120 is recursively executed for the pointer Ap2. As a result, the value of the reference counter Cc1 of the object area C referenced by the pointer Ap2 decreases from 1 to 0 (pointer Ap2
, The object area C is also released (P1209 in P120 for the pointer Ap2), and the value of the pointer Ap2 is set to an invalid value (P121 in P120 for the pointer Ap2).
0). FIG. 41 is an explanatory diagram showing the situation at this stage. In FIG. 40, the reference counter Cc1 is decreased by 1, the object area C is released (broken line), and the pointer Ap2 is set to an invalid value.

P for pointer Ap2 at P1206
When the execution of H.120 is completed and all pointers in the object area A are set to be invalid (Ye in P1207)
s), after releasing the object area A (P1209), the value of the pointer Rp is set to an invalid value (P121).
0), then end P120. FIG. 42 is an explanatory diagram showing a situation at this stage. In FIG. 41, the object area A is opened (broken line), the pointer Rp is set to an invalid value, and as a result, the object area A, the object area B, and the object All areas C are released.

The garbage collection process of the reference counter method shown in the conventional example operates as described above,
It realizes the identification, collection and reuse of "garbage". The reference counter method has a feature and an advantage that the garbage collection process is performed little by little as an extension of the operation of the application program as described above. However, on the other hand, there is a problem in that "refuse" cannot be collected due to the circulating reference. A specific state of this problem will be described with reference to FIGS. 43 and 44.

FIG. 43 is an explanatory diagram showing a state before the second operation of the conventional example. In FIG. 43, the pointer Rp is the pointer 1 existing outside the heap area 2 as in FIG.
2, which refers to the first object area D in FIG. The object area D has a pointer Dp
1 and the pointer Dp2, the pointer Dp1 stores the second object area E, and the pointer Dp2 stores the third
Of the object area F of FIG. The object area E has pointers Ep1 and Ep2 therein.
The pointer Ep1 refers to the object area F like the pointer Dp2, but the pointer Ep2 does not refer to any object area and holds an invalid value. The object area F holds a pointer Fp1 therein, and the pointer Fp1 refers to the object area E. Since the object area D is referenced only by the pointer Rp, the value of the reference counter Dc1 of the object area D is 1. Similarly, since the object area E is referred to by the pointer Dp1 and the pointer Fp1, the value of the reference counter Ec1 is 2, and the object area F is referred to by the pointer Dp2 and the pointer Ep1. Is also 2.

In the situation shown in FIG.
The operation P120 of changing p to an invalid value is as follows. Since the value of the pointer Rp before the change is a valid value referring to the object area D, the process proceeds to P1201 and P1202. As a result of P1202, since the value of the reference counter Dc1 becomes 0, the process proceeds to Yes in P1203. Further, since the object area D includes the pointers Dp1 and Dp2 therein, the process proceeds from Yes in P1204 to P1205. Is performed for P1206. In P1206, P120 is recursively executed for the pointer Dp1, whereby the value of the reference counter Ec1 of the object area E referred to by the pointer Dp1 decreases from 2 to 1 (P12 in P120 for the pointer Dp1).
02). However, here, unlike the above-described first operation of the conventional example, the value of the reference counter Ec1 of the object area E does not become 0, and thus the object area E is not released (P1 in P120 with respect to the pointer Dp1).
203, No), the value of the pointer Dp1 is set to an invalid value (P121 in P120 for the pointer Dp1)
0).

P for pointer Dp1 at P1206
When the execution of step 120 is completed, the processing is No in P1207,
The process proceeds to P1208, and in P1206, P120 is recursively executed for the pointer Dp2. Thereby, the value of the reference counter Fc1 of the object area F referred to by the pointer Dp2 decreases from 2 to 1 (pointer Dp2).
Also, unlike the first operation of the conventional example, the value of the reference counter Fc1 of the object area F does not become 0, so that the object area F is not released (P1202 in P120 with respect to the pointer Dp2).
No in P1203 in 120), the value of the pointer Dp2 is set to an invalid value (P12 for the pointer Dp2).
P1210 in 0).

P for pointer Dp2 at P1206
When the execution of H.120 is completed and all pointers in the object area D are set to be invalid (Ye in P1207)
s), after releasing the object area D (P1209), the value of the pointer Rp is set to an invalid value (P121
0), then end P120. FIG. 44 is an explanatory view showing a situation at this stage after the second operation of the conventional example is performed. In FIG. 43, the reference counter Ec1 and the reference counter Fc1 are decreased, and the object area D is released ( (Broken line), the pointer Rp is set to an invalid value, but as a result, the object area E and the object area F can be referenced from the program via a pointer outside the heap area or a “live” object area. Despite being a "garbage" object area, the area cannot be released.

The problem of "garbage" collection omission in the reference counter method shown in the above-described second operation of the conventional example is that the apparent size of the heap area 2 that can be used in the dynamic memory management mechanism gradually increases. It causes a memory leak phenomenon that it becomes smaller. The occurrence of this phenomenon means that the computer system cannot be operated continuously for a long period of time, and cannot be tolerated in an industrial computer system on the premise of nonstop operation for a long period of time. Therefore, it has been pointed out that the reference counter method needs to be used in combination with another method in order to prevent the "garbage" from being collected.

In the simple reference counter type garbage collection process shown in the first conventional example, if the object area 10 to be released has a valid pointer 12 therein, the object area 1 indicated by the pointer 12
Since the adjustment process of the value of the reference counter is performed recursively even for 0 (P1206), opening of one object area 10 may lead to opening of many object areas 10 in a chain. Change operation P120
There is a problem that the required time is indeterminate and difficult to predict. As a countermeasure against this problem, a second conventional example will be described.

The second conventional example is an improvement of the operation of changing the value of the pointer in the first conventional example.
The configuration and the operation of obtaining the object area are the same as the configuration of the first conventional example (FIG. 36) and the operation of obtaining the object area in the first conventional example (FIG. 37), respectively, and thus the description thereof will be omitted. . The operation of changing the pointer value and the operation of the garbage collection process (GC process) in the second conventional example will be described with reference to FIG.

FIG. 45 is a flowchart showing the operation of the second conventional example. Pointer 12 in second conventional example
In the operation P130 of changing the value of (1), first, similarly to the procedure P120 of the first conventional example, the value held by the pointer 12 is checked (P1201), and if the pointer 12 refers to the valid object area 10 ( Ye of P1201
s), reference counter 1 of object area 10 to be referred to
The value of 1 is subtracted by 1 (P1202). However, as a result, when the value of the reference counter 11 is 0 (P1203
Yes), the object area 10 to be referred to is temporarily added to the garbage list 21 (P1301) instead of immediately performing the processing of releasing the object area 10.
This is a feature different from the operation P120 of changing the value of the pointer 12 in the first conventional example. Thereafter, as in the procedure P120 of the first conventional example, the value of the pointer 12 is set to a new value (P1210). If the value is valid and refers to the object area (Y in P1211)
es), the value of the reference counter 11 of the object area 10 is incremented by 1 (P1212), and the process ends. If the value of the reference counter 11 does not become 0 even if the reference counter 11 of the object area 10 referred to before the value is changed becomes 1 (No in P1203), the value of the target object area 10 is not changed. A new value is immediately set in the pointer 12 without performing the processing for releasing (P121
0), when the value of the pointer 12 before the value is changed is an invalid value (No in P1201), the pointer 1 is promptly changed.
2 is set to a new value (P1210). If the new value to be set to the pointer is an invalid value (N in P1211)
o) Since the reference counter 11 to be updated does not exist, the procedure P212 is not performed, and the process ends promptly.
Is the same as the conventional example.

In step P1301, the object area 10 connected to the garbage list 21 is released by a garbage collection process (GC process) P131 that operates appropriately in parallel with the operation of the application program.

In the procedure P131, first, the garbage list 21
Object area 10 that is included in and is to be released
(P1311), and if any (P1311)
Yes), one unprocessed object area 10 to be released is selected from the garbage list (P1312). At this time, if there is no object area 10 to be released because the garbage list 21 is empty (No in P1311),
Finish the process promptly. Next, regarding the object area 10 selected in the procedure P1312, if the object area 10 holds the pointer 12 therein (P13
13), one unprocessed pointer 12 is selected from among them (P1314), and it is checked whether the value is valid (P1201). If it is valid (Yes in P1201), the pointer 12 is referred to The value of the reference counter 11 of the object area 10 to be subtracted by 1 (P120
2) As a result, if the value of the reference counter becomes 0 (P12
03, Yes), the object area 10 referred to by the pointer 12 is newly added to the garbage list 21 so as to be released (P1301). Then further unprocessed pointer 12
If there is (No in P1315), the unprocessed pointer 12
Procedure P1201, P1202, P1203, P
After repeating 1301, the object area 10 itself obtained from the garbage list and to be released is released using the memory release means 4. Thereafter, if there is still another object area 10 to be released in the garbage list (No in P1316), the unprocessed object area 1
0 for the procedures P1312, P1313. . . .
And the above processing is repeated.

The second conventional example operates as described above, so that unlike the first conventional example, the operation P1 of changing the value of the pointer executed as part of the processing of the application program is performed.
There is a feature and an advantage that the time required for 30 is predictable. However, compared to the first conventional example, the garbage collection process P13 is performed independently of the process of the application program.
1 must be operated, and the processing becomes complicated.
In addition, if the procedure P131 is operated at a high frequency, the load on the system is reduced. If the procedure P131 is performed at a low frequency, the collection and reuse of the “garbage” object area cannot be performed in time for the operation of the application program. It is difficult to decide what to do. Further, as in the first conventional example, there still remains a drawback that "garbage" is leaked due to circulating reference, and it is necessary to use the method in combination with another method. It is necessary to avoid mutual interference, and there is a problem that the processing is further complicated when these are taken into consideration.

Next, a garbage collection process called a mark-sweep method will be described using a third conventional example. The mark-sweep method includes the first and second
This is a method for improving the problem of "garbage" being missed due to circulating reference in the reference counter method shown in the conventional example.

FIG. 46 shows a third conventional example, in which a mark-
FIG. 3 is a configuration diagram of a dynamic memory management mechanism that performs a garbage collection process by a sweep method. In FIG. 46, the dynamic memory management mechanism 1, the heap area 2, the garbage collection means 5, the object area 10, and the pointer 12
6, the description is omitted. Heap area 2 is
Further, it is composed of two areas, a remaining available area 13 composed of a memory area not yet used and an already acquired area 14 composed of a memory area already used by the program. The object area 10
First, the memory area is acquired from the remaining available area 13 which is a part of the heap area 2 by the memory acquiring means 3, and the acquired object area 10 constitutes a part of the already acquired area 14. Further, when the object area 10 is released by the memory releasing means 4, the object area 10 again constitutes a part of the remaining available area 13, and the area can be reused. The available memory area in the remaining available area 13 is managed by the free list 18, and the object area 10 is stored in the free list 1 by the memory acquisition unit 3.
8 is obtained by allocating an appropriate area in the area 8 and returned to the free list 18 by the memory release means 4.

One or more object areas 10 can exist in the already acquired area 14. Unlike the first conventional example, it does not have the reference counter 11 but has a mark 20 area instead. This is a characteristic structure in the garbage collection processing of the mark-sweep method or a type thereof. This mark is a variable mainly holding a state of whether or not the corresponding object area can be regarded as being used, and is operated during the garbage collection process.

Next, the operation of the conventional example will be described.
FIG. 47 is a flowchart showing the operation of the garbage collection process (GC process) in the conventional example. The garbage collection process in this conventional example roughly includes four stages. First, the marks 20 of all the object areas 10 existing in the already acquired area 14 are marked as “unused” (P1401). Next, C
For the PU register, a memory area statically allocated by the program, or all the pointers 12 existing outside the heap area 2 as variables in the stack, an object area 10 directly referred to by the pointers 12
And marks the mark 20 as “in use” (P141). Then, the object area 1 in the already acquired area 14 and the mark 20 is “in use”
0 is searched, and the mark 20 is set to “in use” for the object area 10 referenced from the corresponding object area 10 (P142). Marks 20 of all object areas 10 that can be referenced directly or indirectly from pointer 12 outside the heap area by procedures P141 and P142
Is marked as “in use”, so the mark is “unused” at this stage.
Can be regarded as “garbage”. Finally, all the object areas 10 with the mark “unused” in the already acquired area 14 are marked as “garbage”. Open using (P
143).

Next, procedures P141, P142, P143
The details are shown below. In the procedure P141, first, one of the appropriate pointers 12 outside the heap area 2 is selected (P141
1) If the pointer 12 is valid (Yes in P1201), the object area 1 referenced by the pointer 12
The mark 20 of 0 is set to “in use” (P1412), and this procedure is repeated for all pointers 12 outside the heap area 2 (Yes in P1413, P1414).

In the procedure P142, the object area 10 in which the mark 20 is "in use" is set in the already acquired area 14.
If there is (Yes in P1421), first, one corresponding object area 10 is selected (P1422). If the selected object area 10 includes the pointer 12 therein (Yes in P1313), the selected object area 10 is first selected. Select one of the included pointers 12 (P131
4) If the value is valid and the mark 20 of the reference object area 10 is “unused” (Ye of P1201)
s), the mark 20 of the reference object area 10 is set to “in use” and added to the search target (P1424), and this procedure is repeated for all the pointers 12 included in the selected object area 10 (P1315). N
o) Further, the above procedure is repeated for all the object areas 10 in which the mark 20 is “in use” in the already acquired area 14 (P1425).

In step 143, the object area 10 in which the mark 20 in the already acquired area 14 is "unused" is selected (P1431), and the selected object area 10 is selected.
Is released using the memory release means 4 and connected to the free list 18 (P1209), and this procedure is performed.
(No in P1432).

The specific operation of the conventional example will be described with reference to FIG.

FIG. 48 is an explanatory diagram showing the operation of the conventional example. The situation before the processing shown in FIG.
There are six object areas 10, and each object area 10 is mutually referred to by a pointer 12 existing therein, and a part is further referred to by a pointer 12 outside the heap area 2. FIG. 4 shows a stage where the procedures P1401, P141, and P142 are performed for this state.
8, the value of the mark 20 of each object area 10 is “in use (1)” or “unused” according to the state of reachability from the pointer 12 outside the heap area. (0) ". Further, the stage at which the procedure P143 is performed for this state and the garbage collection process is completed is a state after the release of the unused object area shown in FIG. The object area is freed despite the reciprocal references, and is part of the free list 18.

Since the garbage collection process of the mark-sweep method shown in the conventional example operates as described above, the object area 10 having a circulating reference that cannot be recovered by the reference counter method can be correctly recovered. However, the mark-sweep method still has some problems. One of them is that the garbage collection process must be performed collectively, and there is a drawback that the interruption time of the application program is considerably longer than that of the reference counter method. The other is that a phenomenon called fragmentation occurs. The same applies to the reference counter method. However, in the mark-sweep method, once the object area is acquired, its position remains unchanged until it is released. When the acquisition and the release of the heap area 2 are repeated, the available memory area in the heap area 2 is subdivided, and a large object area cannot be acquired gradually. Similar to the memory leak phenomenon, the occurrence of this phenomenon means that the computer system cannot be operated continuously for a long period of time, and cannot be tolerated in an industrial computer system on which the indefinite test operation over a long period is premised. As a countermeasure against this problem, a fourth conventional example will be described.

The fourth conventional example is a garbage collection process called a mark-compact method, which is a method in which the problem of the fragmentation phenomenon is improved in the mark-sweep method shown in the third conventional example.

FIG. 49 shows a fourth prior art example of a mark-
FIG. 3 is a configuration diagram of a dynamic memory management mechanism that performs garbage collection processing in a compact manner. In FIG. 49, the dynamic memory management mechanism 1, heap area 2, garbage collection means 5, object area 10, pointer 12, mark 20, remaining available area 13, and already acquired area 14 are the same as those in FIG. Is omitted.

The structure of the fourth conventional example shown in FIG. 49 and FIG.
The major difference from the configuration of the third conventional example shown in FIG. 7 is that the available memory area in the remaining available area 13 is not managed using the free list 18 in the fourth conventional example. In the fourth embodiment, the object area 10 is acquired by the memory acquisition means 3 from the remaining available area 13 which is a part of the heap area, and the acquired object area 1
0 constitutes a part of the already acquired area 14, but the memory releasing means 4 operates by being incorporated in the garbage collection means 5, and the object area 10 is individually released by the memory releasing means 4. Instead, they are released collectively during the garbage collection process.

Next, the operation of the conventional example will be described.
FIG. 50 is a flowchart showing the operation of the garbage collection process (GC process) in the conventional example. The garbage collection process in this conventional example, as in the garbage collection process of the third conventional example, roughly takes four steps, and performs the same processing except for the last step.
That is, also in this conventional example, first, the marks 20 of all the object areas 10 existing in the already acquired area 14 are marked as “unused” (P1401), and then the marks 20 exist outside the heap area 2. With respect to all the pointers 12, the object area 10 directly referred to by the pointers 12 is searched, and the mark 20 is marked as "in use" (P141). Is searched for the object area 10 in which the object area 10 is “in use”, and the mark 2 is also set for the object area 10 referred to from the corresponding object area 10.
0 is set to “in use” (P142). Procedure P141, P
Since the marks 20 of all the object areas 10 that can be referred to directly or indirectly from the pointer 12 outside the heap area by “142” are set to “in use”, the already acquired areas 14 whose marks are “unused” at this stage The object area 10 inside can be regarded as “garbage”.

In the last stage of this conventional example, the mark 20 is released from the object area 10 in which the mark 20 is "unused" in the already acquired area 14, and the remaining available area 13 and the mark 20 are set in the "unused" object area. 10 are combined into one, and a remaining available area 13 and an already acquired area 14 are newly set (P151). That is, first, one end of the heap area 2 is determined as a search start end, and an object area existing in the already acquired area 14 and having the mark 20 “in use” is selected from the search start end side (P1511). If there is a vacant area between the search area and the search start end of the heap area 2 (Yes in P1512), the object area 10 is copied and moved to reduce the space so as to eliminate the vacancy (P151).
3). The mark 20 in the already acquired area 14
Is performed on all the object areas 10 that are in use (No in P1514, P1515), the object areas 10 in use are collected on the search start end side of the heap area, and in the heap area 2, The portion where the "in use" object regions 10 are gathered is referred to as a new acquired region 14, and the other portions are referred to as the remaining available region 13 (P151).
6).

The specific operation of the conventional example will be described with reference to FIG.

FIG. 51 is an explanatory diagram showing the operation of the conventional example. In the situation before the processing shown in FIG. 51, there are six object areas 10 in the already-acquired area 14, and the object areas 10 are mutually referenced by the pointer 12 existing therein. The part is referred to from the pointer 12 outside the heap area 2. The state after performing the procedures P1401, P141, and P142 on this state is the state after the search for the valid object area shown in FIG. 51. Each object area 10 is determined according to the state of reachability from the pointer 12 outside the heap area. Is set to “in use (1)” or “unused (0)”. Further, the stage at which the procedure P151 is performed on this state and the garbage collection process is completed is the state after the release of the unused object area shown in FIG. 51, and the two marks whose mark 20 is “unused (0)” The object area is released in spite of the mutually circulating references, and the object area with the mark “in use (1)” is collected at the left end of the heap area 2, and the whole is a new acquired area 14. And the remaining part of the heap area 2 is a new remaining available area 13.

Since the garbage collection process of the mark-compact method shown in the conventional example operates as described above, the problem of the fragmentation phenomenon is avoided unlike the mark-sweep method shown in the third conventional example. However, the mark-compact scheme still has some problems. These problems are caused by moving the object area during the garbage collection process in order to avoid the occurrence of the fragmentation phenomenon. One of the problems is that the copy operation of the area performed for moving the object area is performed. Since the processing is heavy, the interruption time of the application program is longer than that of the mark-sweep method. The other is that, with the movement P1513 of the object area, the reference destination of the pointer 12 referring to the moved object area must be corrected so as to indicate the movement destination, but the processing becomes complicated. .

Next, using the fifth conventional example, the stop-
A garbage collection process called a copy method will be described. The stop-copy method is a further improvement of the mark-sweep method and mark-compact method shown in the third and fourth conventional examples.

FIG. 52 shows the configuration of a dynamic memory management mechanism for performing a garbage collection process called a stop-copy system, which is a fifth conventional example. In FIG. 52,
The dynamic memory management mechanism 1, heap area 2, garbage collection means 5, object area 10, and pointer 12 are the same as those in FIG.

The structure of the fifth conventional example shown in FIG. 52 and FIG.
There are two differences from the configuration of the fourth conventional example shown in FIG. Part 1
One is that the mark 20 is not required in the object area 10 in the fifth conventional example. Second, in the fifth conventional example, a TO area 15 and a FROM area 16 exist in the heap area 2 instead of the remaining available area 13 and the already acquired area 14. TO area 15 and FROM
The area 16 is an area of the same size, and is often set as an area occupying half of the heap area 2 in each case.
In this conventional example, the memory acquisition means 3 is always provided in the FROM area 1
6, an object area 10 is obtained. The memory releasing means 4 operates by being incorporated in the garbage collection means 5 and does not release the object areas 10 individually.

Next, the operation of the conventional example will be described.
FIG. 53 is a flowchart showing the operation of the garbage collection process (GC process) in the conventional example. The garbage collection process in the conventional example roughly includes three stages. First, the procedure P in the third conventional example is described.
In a procedure similar to 141, for all the pointers 12 existing outside the heap area 2, those pointers 1
The object area 10 in the FROM area 16 which is directly referred to from the second area 2 is searched, and each object area 10 is moved to the TO area 15 by copying (P161). Next, T
The object area 10 moved to the O area 15 is searched,
The object area 10 referenced from the corresponding object area 10 is also copied from the FROM area 16.
To the TO area 15 (P162). Procedure P16
1, all object areas 1 that can be referenced directly or indirectly from the pointer 12 outside the heap area by P162
Since 0 has moved to the TO area 15, the object area 10 remaining in the FROM area 16 at this stage can be regarded as "garbage". Finally, the FROM area 16 and the TO area 1
5 and the new FROM area 16 and TO area 15
(P1631). As a result, the procedure P16
1. The object area 10 gathered in the TO area 15 by P162 will be present in the new FROM area 16 and will be retained in the new FROM area 16 together with the object area 10 acquired by the memory acquisition means 3 afterwards. Become.

Next, details of the procedures P161 and P162 will be described. In the procedure P161, first, one of the appropriate pointers 12 outside the heap area 2 is selected (P1411). If the pointer 12 is valid and refers to the object area in the FROM area 16 (Yes in P1611). ,
The object area 10 referenced by the pointer 12 is moved to the TO area 15 by copying (P1612), and this procedure is repeated for all pointers 12 outside the heap area 2 (Yes in P1413, P1414).

In step 162, if there is an unprocessed object area 10 in the TO area 15 (Ye of P1621)
s) First, one corresponding object area 10 is selected (P1622). If the selected object area 10 includes the pointer 12 therein (Yes in P1313), first, the pointer 12 included in the selected object area 10 is selected.
Is selected (P1314), and if the value is valid and the reference object area 10 exists in the FROM area 16 (Yes in P1611), the reference object area 10 is moved to the TO area 15 by copying. This procedure is repeated for all the pointers 12 included in the selected object area 10 (No in P1315), and the above procedure is repeated for all the object areas 10 in the TO area 15. Repeat (No in P1623).

The specific operation of the conventional example will be described with reference to FIG.

FIG. 54 is an explanatory diagram showing the operation of the conventional example. The situation before the processing shown in FIG.
6 object areas 10 in the FROM area 16
Each object area 10 is mutually referred to by a pointer 12 existing inside the object area 10, and a part is further referred to by a pointer 12 outside the heap area 2. The stage at which the procedure P161 was performed for this situation is shown in FIG.
In the situation where the object area referred to from outside the heap area shown in FIG.
The two object areas 10 referred to by
It is moved from the area 16 to the TO area 15 by copying. Further, the stage in which the procedure P162 is performed for this state is a situation in which the object region referred to from the TO region shown in FIG. 54 has been moved, and is referred to from the two object regions 10 moved to the TO region in the previous stage. Object area 10 has newly moved to the TO area. Further, the stage at which the procedure P1631 is performed on this state and the garbage collection process ends is indicated by TO TO shown in FIG.
This is the situation after the exchange of the area and the FROM area, and the memory area occupied by the "garbage" object area 10 can be collected and reused because the FROM area 16 in the previous stage becomes the new TO area 15.

Since the garbage collection process of the stop-copy method shown in the conventional example operates as described above, the "living" object area and the "live" object area are compared with the mark-compact method shown in the fourth conventional example. There is no need to search the entire object area to distinguish "garbage",
There is an advantage that the processing time is fast. Further, by using the following sixth conventional example together, the pointer 1 that refers to the object area moved with the movement of the object area can be obtained.
2 has an advantage that the correction processing can be performed more easily than the mark-compact method. However, at most heap area 2
Since it can be used only up to half the size of the above, there is a disadvantage that the memory utilization efficiency is low.

FIG. 55 is a configuration diagram showing a sixth conventional example. In FIG. 55, heap area 2, TO area 15, FR
The OM area 16 and the pointer 12 are the same as those in FIG. In FIG. 55, the description of the dynamic memory management mechanism 1, the memory acquisition unit 3, the memory release unit 4, and the garbage collection unit 5, which are unnecessary for the description of the sixth conventional example, is omitted.

The major difference between the structure of the sixth conventional example shown in FIG. 55 and the structure of the fifth conventional example shown in FIG. 52 is that the indirect pointer 22 is newly added inside the object area 10 in the sixth conventional example. Is to exist. In the sixth conventional example, the program refers to the object area 10 using both the information held by the pointer 12 and the information held by the indirect pointer 22. Specifically, the program
First, the temporary object area 10 is referred to based on the information held by the pointer 12, and then the true object area 10 is referred to based on the value of the indirect pointer 22 held in the object area 10.

The specific operation of the conventional example will be described with reference to FIG. In FIG. 55, a pointer Rp exists outside the heap area, and three object areas A, B, and C exist in the heap area 2. The pointer Rp existing outside the heap area refers to the object area A. The object area A holds therein the pointers Ap1 and Ap2. The pointer Ap1 refers to the object area B, and the pointer Ap2 refers to the object area C. The object area B holds a pointer Bp1 and a pointer Bp2 therein, and a pointer Bp
1 refers to the object area C, but the pointer B
p2 holds an invalid value without referring to any object area. FIG. 55 also shows an intermediate stage of the stop-copy garbage collection process,
Object area A and object area C are FROM
Although the area 16 has been moved from the area 16 to the TO area 15 by copying, the object area B is still moved from the FROM area 16 to the T area.
It has not moved to the O region 15.

Indirect pointer 2 in object area 10
2 is adjusted so as to refer to the true object area 10 in the garbage collection process.
Here, the true object area is still the FROM area 1
The object area within 6 and not moved to the TO area 15 is an object area in the FROM area, and the object area moved from the FROM area to the TO area is an object area existing in the TO area. In FIG. 55, the object area B in the FROM area and the object area A in the TO area (new)
And the object area C (new), and the indirect pointer 22 inside the object area is set so as to refer to its own object area. On the other hand, the temporary object area is the original object area when the object area moves from the FROM area to the TO area. In FIG. 55, the object area A (old) and the object area C (old) left in the FROM area are shown. Applies,
Indirect pointer 22 inside those object areas
Are set so as to refer to the object areas to which the corresponding TO areas are moved. This setting is a procedure P16 for moving the object area from the FROM area to the TO area.
In step 12, this is realized by changing the indirect pointer 22 of the object area before the movement to refer to the object area of the movement destination.

Since the prior art operates as described above, the process of adjusting the reference relationship of the object when moving from the relatively FROM region to the TO region and the process of referencing the object from the pointer move to the TO region. The reference of the object area moved from the object to the TO area
Reference from the object moved to the O area to the object area in the FROM area that has not yet moved is also performed from the FROM area.
There is an advantage that all references from an object area that has not yet moved to an object area that has moved the TO area can be equally handled in the same procedure. That is, FIG.
, The pointer Ap2 of the object area A (new)
From the pointer to the object area C (new)
2, the object area C (new) is referred to, and the object area C (new) to which the indirect pointer 22 points is referred to again from the object area C (new). Object area A (new)
The pointer Ap1 to the object area B can be correctly obtained by first referring to the object area B from the pointer Ap1, and further referring to the object area B to which the indirect pointer 22 points from the object area B. Then, the pointer Bp of the object area B
1 to the object area C (new)
This is correctly performed by referring to the object area C (old) from p1 and further referring to the object area C (new) to which the indirect pointer 22 points from the object area C (old).

However, in the conventional example described above, it is necessary that the area before the movement is not destroyed when the object area is moved. For this reason, F shown in the fifth prior art example
Although it can be combined with the stop-copy method in which the data is moved from the ROM area to the TO area, it is difficult to combine with the mark-compact method in which the data is moved so as to fill the space in the heap area shown in the fourth conventional example. This conventional example does not provide a solution for maintaining a reference relationship accompanying movement of an object area in the mark-compact system.

Next, the garbage collection processing of the incremental (stepping) method will be described using a seventh conventional example. The incremental method is a technology that improves the responsiveness of the program by shortening the interruption time of the application program by advancing the garbage collection process little by little, and many improvements have been made based on various garbage collection methods. Here, a relatively simple system improved based on the stop-copy system shown as the fifth conventional example will be described.

The configuration of the seventh conventional example and the operation of the garbage collection process are respectively the same as the configuration of the fifth conventional example (FIG. 52) and the operation of the garbage collection process (FIG. 53).
Therefore, the description is omitted. An operation of reading a pointer value in the seventh conventional example will be described with reference to FIG.

FIG. 56 is a flowchart showing the operation of the seventh conventional example. In the operation of reading the value of the pointer, the value of the pointer 12 is valid (Ye of P1201).
s), if the object area 10 referred to by the pointer 12 is in the FROM area 16 (Ye in P1611)
s), the object area 10 of the reference destination is stored in the FROM area 1
6 to the TO area 15 (P1612), and set the reference to the destination to the value of the pointer 12 (P170).
1) The value is passed to the program (P1702), and the process ends. If the reference destination of the pointer 12 is the object area in the TO area (No in P1611) or the value is invalid (No in P1201), the process immediately proceeds to the procedure P1702 and the value is passed to the program as it is.

In the incremental garbage collection based on the stop-copy method shown in the conventional example, the garbage collection process P160 and the operation of the application program can be performed in parallel by operating as described above. As a result, the interruption of the operation of the application program can be shortened similarly to the garbage collection processing of the reference counter method shown as the second conventional example without impairing the advantages of the stop-copy method. However, since the copy process of the object area is included, the interruption time of the operation of the application program is longer than that of the reference counter method.

Next, a garbage collection process of a generational (generation) system will be described using an eighth conventional example. The generational method is a technology that introduces the concept of “generation” into object areas to be subjected to garbage collection processing, and separates and treats object areas of different generations to improve the efficiency of average garbage collection processing. Like the incremental method of the generational method, many improvements have been made based on various garbage collection methods. Here, the mark shown as a fourth conventional example is relatively simple.
Stop shown as compact system and fifth conventional example
A method using the copy method together will be described.

FIG. 57 shows an eighth conventional example, in which a mark-
FIG. 11 is a configuration diagram of a dynamic memory management mechanism that performs a garbage collection process of a generational system using both a compact system and a stop-copy system. In FIG. 57,
The dynamic memory management mechanism 1, the heap area 2, the memory acquisition means 3, the memory release means 4, the garbage collection 5, the pointer 12, the TO area 15, and the FROM area 16 are the same as those in FIG. Since the object area 10 and the mark 20 are the same as those in FIG. 49, the description is omitted. In FIG. 57, TO area 1 is included in heap area 2.
5. In addition to the FROM area 16, there is an OLD area 23. TO area 15, FROM area 16, OLD area 2
3 is an area of the same size, and is set as an area divided into three equal parts of the heap area 2 in many cases. In this conventional example, as in the fifth conventional example, the memory acquisition means 3 is always FR
The object area 10 is acquired from the OM area 16, and the memory releasing means 4 operates by being incorporated in the garbage collection means 5, and does not individually release the object area 10.

Next, the operation of the conventional example will be described.
In this conventional example, the generation of the object area is divided into a young generation and an old generation. The young generation object area is F
It exists in the ROM area. The old generation object area exists in the OLD area. First, garbage collection for the young generation will be described.

FIG. 58 shows a garbage collection process (G
9 is a flowchart showing the operation of (C process). In this conventional example, the garbage collection process for the young generation is performed according to the stop-copy method shown in the fifth conventional example. First, the pointer 12 included in the old object area in the OLD area 23 is moved out of the heap area. The garbage collection process is performed in a certain manner (P1801), and a garbage collection process is performed from the FROM area 16 to the TO area 15 by a method according to the stop-copy type procedures P161 and P162 (P1802). Then, the FROM area 16 and T
The O area 15 is replaced and the new FROM area 16 and the TO area 15 are defined again (P1631).

The specific operation of the garbage collection process for the young generation of the prior art will be described with reference to FIG.

FIG. 59 shows a first operation of the conventional example.
It is an explanatory view showing operation of garbage collection processing to a young generation. The situation before the processing shown in FIG. 59 is based on the FROM area 16 and the OLD area 23 in the heap area 2.
The object area 10 exists only within the heap area 2, and a part thereof is referred to by the pointer 12 outside the heap area 2. The stage at which the procedures P1801 and P1802 are performed with respect to this state is the state after the processing shown in FIG. 59. The object area 10 existing in the OLD area 23 has not changed, but the Has been moved to the TO area 15 and the reference of the pointer 12 outside the heap area 2 has been changed to point to the inside of the TO area. In the situation before the processing shown in FIG. 59, the pointer 12 in the FROM area 16 outside the heap area 2 and the pointer 12 held in the object area 23 in the OLD area 23 directly or Object area 1 that could not be referenced indirectly
0 is not moved to the TO area 15 in the situation after the processing shown in FIG. 59, but is collected and reused as “garbage”.

Next, the garbage collection process of the old generation, which is the second operation of the conventional example, will be described. FIG. 60 is a flowchart showing the operation of the garbage collection process for the old generation, which is the second operation of the conventional example. In this conventional example, the garbage collection process for the old generation is performed in accordance with the mark-compact method shown in the fourth conventional example. First, if the object area 10 exists in the TO area 15, it is included in the object area 10. The pointer 12 is handled as if it is outside the heap area (P1901).
The garbage collection process is performed by a method in accordance with the mark-compact procedure P140 so that the LD region 23 is regarded as one region and the OLD region 23 is preferentially packed (P1902).

The specific operation of the garbage collection process for the old generation of the prior art will be described with reference to FIG.

FIG. 61 shows a second operation of the conventional example.
It is an explanatory view showing operation of garbage collection processing to an old generation. The situation before the processing shown in FIG. 61 is similar to the situation before the processing shown in FIG. 59, in which the object area 10 exists only in the FROM area 16 and the OLD area 23 in the heap area 2, and a part of the object area 10 It is referenced from the pointer 12 outside the heap area 2. The state after performing the procedures P1901 and P1902 with respect to this state is the state after the processing shown in FIG. 61, in which the object area 10 existing in the OLD area 23 and the object area existing in the FROM area are compared. Of these, the object area 10 that could not be directly or indirectly referred to from the pointer 12 outside the heap area 2 is omitted, and the remaining object areas 10 are grouped so that the OLD area 23 is packed first. Garbage is collected and reused. When the object areas are put together, the FROM area 16
And the OLD area 23 are not straddled by the object area 10. In the situation after the processing shown in FIG. 61, as a result of the garbage collection processing on the old object area, the surviving object area cannot be completely contained in the OLD area 23, and a part of the FROM area 1
6 also exists. The object area existing in the FROM area 16 participates in a garbage collection process for a new generation. On the other hand, OLD region 2
Even if the object area in 3 becomes “garbage” that cannot be referenced from any pointer due to the operation of the program, as shown in FIG. 59, it is not possible to collect and reuse the object area in the garbage collection process for the new generation. Absent.

Since the generational garbage collection process shown in the conventional example operates as described above, both the new generation garbage collection process and the old generation garbage collection process target an area smaller than the entire heap area 2. , The processing time can be shortened. In addition, according to research results on garbage collection processing shown in the past, generally, in the operation of many programs, the newly generated object area 10 tends to become “garbage” earlier, and conversely, “live” for a certain time or longer. It has been observed that the object area 10 is less likely to become "garbage", and in the situation where this tendency is established, the object area that fits in the OLD area 23 is likely to be long-lived. Even with only a new generation of garbage collection processing, an effect similar to garbage collection processing for the whole can be expected, and processing efficiency is improved. Furthermore, in this conventional example, up to 2/3 of the maximum heap memory area can be used, and there is an advantage that the memory use efficiency is improved as compared with the stop-copy method shown as the fifth conventional example. However, in general garbage collection processing of not only this conventional example but also the generational garbage collection processing, there is a problem in what ratio and at what timing garbage collection processing for the young generation and garbage collection processing for the old generation are performed. Yes, and in the first place, the generational method aims to improve the average efficiency of general programs, so it can be obtained if the tendency of the program behavior is different from the above and the assumption about the lifetime of the object area is broken There is also a problem that the effect is small or worse.

[0081]

The conventional dynamic memory management mechanism as described above causes a memory leak phenomenon, a fragmentation phenomenon, and the like, meaning that the computer system cannot be operated continuously for a long period of time. There is a problem that it cannot be tolerated in an industrial computer system that is premised on operation.

The present invention has been made in order to solve the above-mentioned problems, and enables continuous operation for a long period of time mainly for a computer system used in the industrial field, is simple in processing, and has low efficiency. The objective is to obtain a dynamic memory management mechanism with garbage collection means that can improve the responsiveness of the operation of application programs and the responsiveness of the computer system, and also has the effect of shortening the time required for system startup. And

[0083]

A dynamic memory management mechanism according to the present invention comprises: a heap area; memory acquisition means for acquiring a part of the heap area from the heap area as an object area; Memory releasing means for returning to an area and being reusable; garbage collection means for searching for an object area acquired by the memory acquiring means but no longer used by the program, and releasing the object area to the heap area using the memory releasing means Wherein each of the object areas has a reference counter indicating its use status, and each of the reference counters increases or decreases to indicate the number of pointers referring to the corresponding object area, and the garbage collection means Is the object corresponding to when the value of the reference counter becomes 0. When the garbage collection processing of the reference counter method for releasing an area and the garbage collection processing of another method are operated together, when the value of the reference counter becomes 0 and the corresponding first object area is released. In addition, only the first object area is released, and for the second object area referenced by a plurality of one or more pointers in the first object area, the reference counter value updating processing and the same processing are performed. This does not perform the process of releasing the object area that may occur in association with it.

In the dynamic memory management mechanism according to the present invention, when the garbage collection means releases the first object area when the value of the reference counter becomes 0, 1 in the area
Or setting the values of a plurality of pointers to invalid values.

According to the dynamic memory management mechanism of the present invention, a heap area, memory acquisition means for acquiring a part of the heap area as an object area, and the acquired object area can be returned to the heap area for reuse. Garbage collection means for searching for an object area acquired by the memory acquisition means but no longer used by the program, and releasing the object area to the heap area using the memory release means,
The memory acquisition means sequentially acquires an object area from one end of the remaining available area in the heap area, and the garbage collection means first sets the remaining available area as a TO area, and sets the same amount adjacent to the TO area. Or, an already acquired area smaller than that is set as a FROM area, a partial garbage collection process is performed by moving individual object areas by copying, and then the object area of the TO area remains available without being moved. The new remaining available area, which is the combination of the area and the empty FROM area, is defined as a new TO area, and a new area of the same amount as the new remaining available area among the already acquired areas that have not yet been subjected to the garbage collection process is newly created. The partial garbage collection process is performed again as a simple FROM area, and garbage Until di collection process is over, it is intended to repeat the same in part garbage collection process or later.

Further, in the dynamic memory management mechanism according to the present invention, when the garbage collection means repeats the partial garbage collection processing, the size of the newly generated remaining available area in the middle of the garbage collection processing exceeds a certain threshold. If so, stop the repetition.

Further, in the dynamic memory management mechanism according to the present invention, before the garbage collection means repeats the partial garbage collection processing, first, the garbage collection means firstly generates a base pointer list of an object area referenced from a pointer existing outside the heap area. In the partial garbage collection process that is created and subsequently repeated, the process is performed using the pointer held by the base pointer list instead of the pointer existing outside the heap area, and the object area referenced by the pointer is copied to the TO area. If so,
The pointer is deleted from the base pointer list.

Further, in the dynamic memory management mechanism according to the present invention, the garbage collection means may be configured such that, when the garbage collection process is repeated, the remaining available area as the TO area always moves in the heap area in one direction. The order in which the object areas are obtained from the remaining available area and the relative positions of the FROM area and the TO area in the heap area are fixed.

Further, in the dynamic memory management mechanism according to the present invention, the garbage collection means may be configured such that, when the garbage collection process is repeated, the remaining available area as the TO area reciprocates in the heap area. And the relative position of the FROM area and the TO area in the heap area.

Further, in the dynamic memory management mechanism according to the present invention, when the garbage collection means has a small remaining available area, which is a TO area, the garbage collection means deletes the TO area from the already acquired area.
The FORM area to be set adjacent to the area is set to be larger than the amount of the TO area. First, a search for an effective object area in the FROM area is performed without moving the object area. Is stored at one end of the combined area of the FROM area and the TO area to increase the remaining available area, and then execute the partial garbage collection process.

According to the dynamic memory management mechanism of the present invention, there is provided a heap area, memory acquisition means for acquiring a part of the heap area from the heap area as an object area, and the acquired object area can be returned to the heap area for reuse. Memory releasing means, and garbage collection means for searching for an object area acquired by the memory acquiring means but no longer used by the program, and releasing the object area to the heap area using the memory releasing means,
The pointer that refers to each of the object areas directly points to an entry of the reference table, and the reference of the object area by the pointer is always performed via the entry of the reference table.

According to the dynamic memory management mechanism of the present invention, there is provided a heap area, memory acquisition means for acquiring a part of the heap area from the heap area as an object area, and returning the acquired object area to the heap area for reuse. Garbage collection means for searching for an object area acquired by the memory acquisition means but no longer used by the program, and releasing the object area to the heap area using the memory release means,
The garbage collection means operates to periodically perform a garbage collection process only for a certain period of time or less.

Also, in the dynamic memory management mechanism according to the present invention, the garbage collection means refers to a flag whose true / false changes periodically at a constant ratio, and only when the flag is true, the garbage collection means It operates to perform processing.

Further, in the dynamic memory management mechanism according to the present invention, the garbage collection means includes a counter indicating whether or not garbage collection processing can be performed and a counter increasing means for periodically increasing the counter by an appropriate value. And operates so as to perform the garbage collection process only while the value of the counter is positive while subtracting the value of the counter according to the progress of the garbage collection process.

Further, in the dynamic memory management mechanism according to the present invention, the garbage collection means may set the counter value to be negative until the amount of the remaining available area in the heap area exceeds a certain threshold. Also continues the garbage collection process.

According to the dynamic memory management mechanism of the present invention, there is provided a heap area, memory acquisition means for acquiring a part of the heap area as an object area, and the acquired object area can be returned to the heap area for reuse. Garbage collection means for searching for an object area acquired by the memory acquisition means but no longer used by the program, and releasing the object area to the heap area using the memory release means,
The garbage collection means uses a different garbage collection method as appropriate depending on the system state such as the reason for performing the garbage collection process, the operation state of the program, the internal state of the dynamic memory management mechanism, or the operation state of the system. It is something to use properly.

Further, in the dynamic memory management mechanism according to the present invention, the garbage collection means requests the memory acquisition means from the application program during the operation of the application program due to a shortage of the remaining available area in the heap area. A different garbage collection method is used depending on whether a temporary operation is performed because the amount of object area cannot be acquired and a case where the processing is performed at a preset timing.

Further, in the dynamic memory management mechanism according to the present invention, the garbage collection means is acquired by the memory acquisition means after the most recently performed garbage collection processing, and is still subjected to garbage collection processing. Different garbage collection methods are used depending on the number of object areas that do not have any.

Further, the dynamic memory management mechanism according to the present invention is characterized in that the garbage collection means operates when the computer system is operating as a system startup stage and when the computer system is operating as a system steady stage. Different garbage collection methods are used.

According to the dynamic memory management mechanism of the present invention, a heap area, memory acquisition means for acquiring a part of the heap area from the heap area as an object area, and the acquired object area can be returned to the heap area for reuse. Garbage collection means for searching for an object area acquired by the memory acquisition means but no longer used by the program, and releasing the memory area to the heap area using the memory release means,
When the garbage collection process is required by the operation of the application program, the garbage collection process is not performed immediately, but the operation of the application program is stopped until the garbage collection process that is performed at a separately determined timing ends. is there.

Further, the dynamic memory management mechanism according to the present invention does not immediately perform garbage collection processing when an garbage collection instruction is explicitly issued from an application program, but at a separately determined timing. The operation of the application program is stopped until the garbage collection process is completed.

Further, in the dynamic memory management mechanism according to the present invention, when the application program tries to acquire the object area by using the memory acquisition means, the application program needs from the remaining available area in the heap area. When the garbage collection process becomes necessary because the object area cannot be obtained, the garbage collection process is not performed immediately. The operation is stopped.

Further, the dynamic memory management mechanism according to the present invention, when a plurality of application programs are waiting for the end of the garbage collection processing, the remaining available area in the heap area increased by the garbage collection processing is As we meet each of the program's requirements,
The stop of each program is sequentially released when the processing can be continued.

Then, the information recording medium according to the present invention
A program for a computer system for realizing the dynamic memory management mechanism according to any one of claims 1 to 21 is recorded.

[0105]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Embodiment 1 A dynamic memory management mechanism according to Embodiment 1 of the present invention will be described with reference to the drawings. FIG. 1 is a block diagram showing a configuration of the dynamic memory management mechanism according to Embodiment 1 of the present invention.
In the drawings, the same reference numerals indicate the same or corresponding parts.

The structure of the first embodiment is the same as the structure of the first conventional example shown in FIG. 36, and the dynamic memory management mechanism 1 includes a heap area 2 which is a part of the memory area of the computer system. A memory acquisition unit 3 for acquiring a part of the same heap area 2 as an object area 10, a memory release unit 4 for returning the acquired same object area 10 to the same heap area 2 for re-use, and a memory acquisition The garbage collection means 5 searches for the object area 10 acquired by the means 3 but is no longer used by the program, and releases it to the heap area 2 using the memory release means 4. Although the heap area 2 is a single memory area whose addresses are continuous in the first embodiment, the heap area 2 can be easily composed of a plurality of memory areas.

In the heap area 2, one or a plurality of object areas 10 can exist. Each object area 10 is a small memory area in the heap area 2 that is generated by the memory acquisition unit 3 and deleted by the memory release unit 4. Various kinds of information necessary for the operation of the program are appropriately held in the object area 10.
The information held in the object area 10 largely depends on the development language and program design of the program, and may include only data necessary for the operation of the program, or may include instruction codes of the program.

Each object area 10 has a reference counter 11. This is a characteristic structure in the garbage collection process of the reference counter method. The reference counter 11 is a variable that holds an integer value, and the value indicates the number of pointers 12 to which the corresponding object area 10 is referenced. Show.

The pointer 12 is program data that needs to be considered when performing garbage collection processing. The pointer 12 indicates that the program is in the object area 1
This is a storage area for holding information necessary to reference 0, and exists as a CPU register of a computer, a memory area or a stack in a memory (small memory area) where a program is statically arranged, and a variable in the object area 10. I do.

Next, the operation of the dynamic memory management mechanism according to the first embodiment will be described with reference to the drawings. The first embodiment is an embodiment of the invention relating to the garbage collection process of the reference counter system on the assumption that it is used in combination with another system.
Performs a garbage collection process using both the reference counter method according to the present invention and another method. Another garbage collection method used in combination is the second conventional garbage collection method.
43 (FIG. 43) and FIG. 45 (FIG. 43), any method may be used as long as it avoids the two problems of the omission of collection due to the cyclic reference of the object area and the fragmentation phenomenon shown in the third conventional example. For example, the mark-compact method shown as the fourth conventional example, the stop-copy method shown as the fifth conventional example, further another conventional method which is an improvement thereof, and the method shown in claim 3 of the present invention. And the like can be adopted, and the effects of the present invention can be achieved by combining any of them.

The operation of acquiring an object in the first embodiment is the same as that of the first conventional example (FIG. 37). In the operation of acquiring the object area 10, first, an unused portion in the heap area 2 is explicitly specified by a program. Acquires an appropriate or implicitly specified memory area (P
1101), the next acquired area is the object area 10
And the value of the reference counter 11 is set to 0 (P
1102) Further, if necessary, other places (data) in the acquired object area are initialized (P1).
103) Then, the value of the pointer 12 necessary for referring to the object area 10 is returned. Here, the procedure P11
The reason why the value of the reference counter 11 is set to 0 at 02 is that the newly generated object area 10 has a pointer 1
2, because the number of pointers 12 referring to the object area is 0.

FIG. 2 is a flowchart showing the operation of changing the value of pointer 12 in the first embodiment. In the operation S120 of changing the value of the pointer 12, first, the validity of the value held by the pointer 12 that changes the value is checked (P1201). If the pointer 12 refers to the object area 10 before the value is changed (P1201
Yes), the object area 1 of the reference destination by this change
Since the number of pointers 12 referring to 0 is reduced, the value of the reference counter 11 of the object area 10 is decremented by 1 (P1
202). As a result, if the value of the reference counter 11 is 0 (Yes in P1203), the target object area 10 becomes an object area 10 that is not referenced by any pointer 12, that is, "garbage". The object area 10 is released using the means 4 (P1209). Thereafter, the value of the pointer 12 is set to a new value (P1210). If the value is valid and refers to the object area 10 (Y in P1211)
es) Since the number of pointers 12 that refer to the reference destination object area 10 increases, the value of the reference counter 11 of the object area 10 is incremented by 1 (P1212), and the process ends.

If the value of the reference counter 11 does not become 0 even when the value of the reference counter 11 of the object area 10 referred to by the pointer 12 before the value is changed becomes 1 (No in P1203), the object is regarded as a target. Object area 1
Since 0 is still referred to by the other pointer 12 and is the object area 10 in use, a new value is immediately set to the pointer 12 without releasing the object area 10 (P1210). This occurs when the value of the pointer 12 before changing the value is an invalid value (P12
The same applies to No. 01), which promptly sets a new value to the pointer 12 (P1210). If the new value set in the pointer 12 is an invalid value (N in P1211)
o) Since the reference counter 11 to be updated does not exist, the procedure P1212 is not performed, and the process ends immediately.

The specific operation of the first embodiment will be described with reference to FIGS. 3 and 4. FIG.

FIG. 3 is an explanatory diagram showing a state before the operation according to the first embodiment is performed. FIG. 3 is the same as the explanatory diagram (FIG. 39) showing the first conventional example before the first operation is performed. A pointer 12 existing outside the heap area 2 as an area or a variable in the stack, and refers to the first object area A. The object area A holds therein the pointers Ap1 and Ap2, the pointer Ap1 refers to the second object area B, and the pointer Ap2 refers to the third object area C. Object area B
Holds a pointer Bp1 and a pointer Bp2 therein, and the pointer Bp1 refers to the object area C like the pointer Ap2, but the pointer Bp2 does not refer to any object area and holds an invalid value.
The object area C does not hold the pointer 12 therein. Since the object area A is referenced only by the pointer Rp, the reference counter A of the object area A
The value of c1 is 1. Similarly, since the object area B is referenced only by the pointer Ap1, the value of the reference counter Bc1 is 1, and since the object area C is referenced by the pointer Ap2 and the pointer Bp1, the value of the reference counter Cc1 is Is 2.

In the situation shown in FIG.
The operation S120 for changing to an invalid value is as follows.
Since the value of the pointer Rp before the change is a valid value referring to the object area A, the process proceeds to P1201 and P1202.
As a result of P1202, the value of the reference counter Ac1 becomes 0, so the processing proceeds to Yes in P1203, and the object area A
Is released (P1209), the value of the pointer Rp is set to an invalid value (P1210), and then S120 is terminated. FIG. 4 is an explanatory view showing the situation at this stage. In FIG. 3, the object area A is opened (broken line) and the pointer Rp is set to an invalid value. In this procedure S120, unlike the procedure P120 of the first conventional example, the object area B and the object area C are not released, but they are collected by another garbage collection process which is separately performed.

As described in the description of the first conventional example, the garbage collection processing of the reference counter method has a problem that it is difficult to collect "garbage" due to a cyclic reference between object areas. It has been pointed out that it needs to be used in combination with other methods. The first embodiment is different from the first conventional example in that the operation of changing the value of the pointer is performed as described above on the assumption that it is used in combination with another method for avoiding the problem of the cyclic reference. In the second conventional example in which the time required for the operation S120 of changing the value of the pointer is predictable and has the same effect, a dedicated garbage for releasing the object area in which the reference counter becomes 0 is provided. Collection processing P13
1 is unnecessary, and the garbage collection means 5 can be simplified.

Embodiment 2 Embodiment 2 of the present invention
Is a modification of the operation of changing the value of the pointer in the first embodiment. The basic configuration and the operation of acquiring the object area are the same as those in the first embodiment, and thus the description is omitted.

FIG. 5 shows a pointer 1 according to the second embodiment.
9 is a flowchart illustrating an operation of changing a value of 2. Operation S13 of Changing Value of Pointer 12 in Second Embodiment
Even if it is 0, the value held by the pointer 12 is checked first (P1201) as in the procedure S120 of the first embodiment. If the pointer 12 refers to a valid object area 10 (Yes in P1201), the value is referred to. The value of the reference counter 11 of the object area 10 is decremented by 1 (P12
02). However, as a result, when the value of the reference counter 11 is 0 (Yes in P1203), the object area 10 is not immediately released, but one or more object areas 10 are contained therein. (Yes in P1204), all the pointers 12 existing in the object area 10 are stored.
Are set to invalid values (S1301, P1207, P1208), and then the target object area 10 is released using the memory release means 4 (P1209). After that, as in the first embodiment, the value of the pointer 12 is set to a new value (P121
0), if the value is valid and refers to the object area 10 (Yes in P1211), the number of pointers 12 referring to the referenced object area 10 increases, so that the reference counter 11 of the object area 10 The value is incremented by 1 (P1212), and the process ends. This is because the value of the pointer 12 before changing the value is an invalid value (No in P1201), or the reference counter 11 of the object area 10 referenced by the pointer 12 before changing the value is decremented by one. If the value of the reference counter 11 does not become 0 (No in P1203), the process of releasing the object area 10 is not performed, and a new value is immediately set to the pointer 12 (P1210), and the pointer 12 is set. If the new value is an invalid value (No in P1211),
Since there is no reference counter 11 to be updated, the procedure P1 is performed.
This is the same as the first embodiment in that the step 212 is not performed, and the process is immediately completed.

The specific operation of the second embodiment will be described with reference to FIG. 3 and FIG.

The explanatory diagram before the operation of the second embodiment is performed is the same as the explanatory diagram (FIG. 3) before the operation of the first embodiment, and the description is omitted. In FIG.
The operation S130 of changing the pointer Rp to an invalid value is as follows. Since the value of the pointer Rp before the change is a valid value referring to the object area A, P1201, P12
Proceed to 02. As a result of P1202, the value of the reference counter Ac1 becomes 0, so the process proceeds to Yes of P1203, and the object area A further includes pointers Ap1 and Ap therein.
Since P2 is included, the process proceeds from Yes in P1204 to P1205, and first sets the value of the pointer Ap1 to an invalid value (S1301). After that, the process is P120
In step S1301, the value of the pointer Ap2 is set to an invalid value. When all the pointers in the object area A have been set to be invalid (Yes in P1207), the object area A is released (P1209), and then the value of the pointer Rp is set to an invalid value (P1210). Finish. FIG. 6 is an explanatory diagram showing the situation at this stage. In FIG. 3, the pointers Ap1 and Ap2 are set to invalid values, the object area A is released (broken line), and the pointer Rp is set to invalid values. You. This situation is described in Embodiment 1.
4 in that the values of the pointers Ap1 and Ap2 are invalid.

The second embodiment operates as described above, so that the time required for the operation of changing the value of the pointer 12 S130 is longer than that of the first embodiment, but is longer than that of the first embodiment. The time required for changing the value of the pointer 12 can be reduced, and the garbage collection means 5 can be simplified as compared with the second conventional example, as in the first embodiment.
Further, unlike Embodiment 1, by setting the pointer 12 included in the object area 10 to be released to an invalid value, garbage identification in the garbage collection processing of another system used together becomes easy, and the efficiency of the processing is reduced. Can be higher.

In the second embodiment, invalid values are set for all the pointers 12 in the object area 10 to be released (procedures P1205, S1301, and P120).
7, Yes, P1208), by setting an upper limit on the number of pointers 12 to be processed, it is possible to predict the time required for the operation of changing the pointer value, as in the first embodiment. In addition, the number of the upper limit is, for example, C
The weight of the processing required for the operation of changing the value of the pointer 12 and the weight of the garbage collection processing of another system to be used together are changed by changing the value of the pointer 12 according to the operation state of the system such as the PU load state. Control can be appropriately performed according to the situation, and the efficiency and responsiveness of the entire system can be improved.

Further, the method of the second embodiment or a method developed from the second embodiment is applied to the reference counter system shown in the first conventional example, and the pointer 12 of the first conventional example is used. In the value change operation P120, the pointer 1
By setting an upper limit on the number of object areas 10 recursively released along with the change of the value of 2 and the number of pointers 12 set to be invalid, the operation of changing the value of the pointer 12 is performed as in the first embodiment. Can be predicted, and by changing the upper limit, the weight of the processing required for the operation of changing the value of the pointer 12 can be
It is possible to control the weight of the garbage collection process of another system used together, and to improve the efficiency and responsiveness of the entire system.

Embodiment 3 A dynamic memory management mechanism according to Embodiment 3 of the present invention will be described with reference to the drawings. FIG. 7 is a block diagram showing a configuration of the dynamic memory management mechanism according to Embodiment 3 of the present invention. 7, the dynamic memory management mechanism 1, the heap area 2, the garbage collection means 5, the object area 10, and the pointer 12 are the same as those in FIG. The heap area 2 further includes two areas: a remaining available area 13 composed of a memory area not yet used and an already acquired area 14 composed of a memory area already used by the program. You. Object area 1
0 is first acquired from the remaining available area 13 which is a part of the heap area 2 by the memory acquiring means 3, and the acquired object area 10 constitutes a part of the already acquired area 14. Also, object area 1
When 0 is released by the memory releasing means 4 which is incorporated in the garbage collection means 5 and operates, the part becomes a part of the remaining available area 13 again, and that area becomes reusable.

Next, the operation of the third embodiment will be described. FIG. 8 is a flowchart showing the operation of the garbage collection process (GC process) according to the third embodiment. First, the remaining available area 13 at the start of the processing is determined as the first TO area 15 (S1401), and the garbage collection processing has not yet been performed in the already acquired area 14 and is adjacent to the TO area 15. TO area 15
The area equal to or smaller than the FROM area 1
6 (S1402). When the FROM area 16 is determined, the object area 10 extending over the boundary of the FROM area 16 is set so that the TO area 15 does not overflow even if all the object areas 10 included in the FROM area 16 are moved to the TO area 15. If there is, the object area 10 is excluded from the FROM area 16. Next, a partial garbage collection process (partial GC process) is performed by roughly taking the following three stages. First, for the CPU register of the computer, a memory area where the program is statically arranged, or all the pointers 12 existing outside the heap area 2 as variables in the stack, a FROM area directly referred to by the pointers 12 1
6 is searched for, and each object area 10 is moved to the TO area 15 by copying (P1).
61). Next, all the object areas 10 other than the FROM area 16 in the already acquired area 14 are searched, and the object areas 10 in the FROM area 16 directly referred to from the object areas 10 are also moved to the TO area 15. (S141). Finally, the object area 10 moved to the TO area 15 is searched, and the object area 10 referred to by the corresponding object area 10 is also moved from the FROM area 16 to the TO area 15 by copying (P162). Procedure P161,
By S141 and P162, from the pointer 12 outside the heap area 2 and the FROM area 16 of the already acquired area 14
Since all the object areas 10 that can be referred to directly or indirectly from the existing object areas 10 have moved to the TO area 15, the object areas 10 remaining in the FROM area 16 at this stage can be regarded as "garbage". Partial garbage collection processing (P161, S14
1, P162) is completed, the remaining area of the TO area 15 where the object area 10 has not been copied and the empty FROM area 16 are combined, and a new remaining available area 1 is obtained.
3 (S1403), and if there is an unprocessed portion of the partial garbage collection process remaining in the already acquired region 14 (Yes in S1404), the partial garbage collection process is further repeated to obtain the already acquired region. 14 so that the garbage collection process is performed on the entirety of 14.

Next, procedures P161, S141, P16
2 is shown below. In the procedure P161, first, the heap area 2
Select one of the outside appropriate pointers 12 (P141
1) If the pointer 12 is valid and refers to the object area 10 in the FROM area 16 (P161
1 (Yes), the object area 10 referred to by the pointer 12 is moved to the TO area 15 by copying (P161).
2), this procedure is repeated for all pointers 12 outside the heap area 2 (Yes in P1413, P14
14).

In step S141, if there is an object area 10 in the acquired area 14 other than the FROM area 16 (Yes in S1411), one corresponding object area 10 is selected first (S1412), and the selected object area 10 is selected. If 10 includes a pointer 12 inside (P1
313, Yes), first, the selected object area 10
Is selected (P1314),
If the value is valid and the referenced object area 10 is FROM
If it exists in the area 16 (Yes in P1611),
The object area 10 of the reference destination is moved to the TO area 15 by copying and added to the processing target (P1612), and this procedure is repeated for all the pointers 12 included in the selected object area 10 (No in P1315),
Further, the above procedure is repeated for all the object areas 10 other than the FROM area 16 in the already acquired area 14 (No in S1413).

In procedure P162, if there is an unprocessed object area 10 in the TO area 15 (Ye in P1621)
s) First, one corresponding object area 10 is selected (P1622). If the selected object area 10 includes the pointer 12 therein (Yes in P1313), first, the pointer 12 included in the selected object area 10 is selected.
Is selected (P1314), and if the value is valid and the reference object area 10 exists in the FROM area 16 (Yes in P1611), the reference object area 10 is moved to the TO area 15 by copying. This procedure is repeated for all the pointers 12 included in the selected object area 10 (No in P1315), and the above procedure is repeated for all the object areas 10 in the TO area 15. Repeat (No in P1623).

The specific operation of the third embodiment will be described with reference to FIG.

FIG. 9 is an explanatory diagram showing the operation of the third embodiment. In the situation before the processing shown in FIG. 9, the remaining available area 13 is set as the first TO area 15 (S1401), and the area having the same amount as the TO area 15 adjacent to the TO area 15 in the already acquired area 14 is first set. (S1402) when the FROM area 16 is set. 1 for this situation
The second partial garbage collection process (P161, P1
41, P162), the procedure S1403, the procedures S1401, S1402, and the setting of the new TO area 15 and the FROM area 16 are the states after the first partial GC processing shown in FIG. At this stage, in the object region included in the previous stage FROM area 16, "garbage" is removed by the same processing as the stop-copy method shown as the fifth conventional example, and the TO stage of the previous stage is removed.
The area gathered in the area 15 on the right side in the figure of the area 15 and the surplus area (the area on the left side in the figure) of the TO area 15 in the previous stage and the FR in the previous stage
The OM area 16 is merged and set as a new TO area 15,
In addition, an area of the same amount adjacent to the new TO area 15 in the already acquired area 14 that has not been subjected to the garbage collection process is set in the new FROM area 16. For this situation, the second partial garbage collection process (P161, P141, P162) and procedure S140
3. Further, steps S1401 and S1402 are performed and a new T
When the O region 15 and the FROM region 16 are set,
This is the situation after the second partial GC processing shown in FIG. 9, and the third partial garbage collection processing (P16
1, P141, P162) and the step S1403 are the states after the third partial GC processing shown in FIG. After the third partial GC process in FIG. 9, there is no more acquired area 14 that has not yet been subjected to the garbage collection process, so there is no need to repeat the partial garbage collection process, and the entire garbage collection process ends.

By operating as described above, in the third embodiment, a fragmentation phenomenon occurs in which an object area having a circulating reference can be correctly collected similarly to the stop-copy method described in the fifth conventional example. do not do,
It has the advantage that the processing for distinguishing between "live" object areas and "garbage" is fast, and, unlike the stop-copy method, can use more than half of the heap area 2 and has a high memory utilization efficiency. Can be increased.

In the third embodiment, the same procedure (procedures P161, S141, P16) as the stop-copy method described in the fifth conventional example is used for the partial garbage collection processing.
Since 2) is used, the third embodiment is applied by applying an existing technology for converting the stop-copy method into an incremental method as shown in the seventh conventional example.
Can be easily extended to incremental systems,
The constant response of the computer system can be improved.

In the third embodiment, when the partial garbage collection process is repeated, the process is highly independent between the repetitions.
In the part returning to the step, the garbage collection process is temporarily stopped to execute the operation of the application program, and the interruption time of the operation of the application program due to the garbage collection process can be easily reduced. With such deformation,
The responsiveness of the operation of the application program can be improved with little overhead without applying the technique of the incremental system. At this time, in the repetition of the partial garbage collection process, by setting an upper limit on the size of the TO area 15 used, the processing time of each partial garbage collection process can be shortened and predictable, and the application program The responsiveness of the operation can be further improved.

In the third embodiment, when the partial garbage collection process is repeated, the process is terminated when the size of the newly formed available remaining area 13 exceeds a predetermined threshold. so,
The processing time of the entire garbage collection process can be reduced. In this case as well, an upper limit is fixedly or adaptively imposed on the size of the TO area 15 in the repetition of the partial garbage collection process, so that an unnecessary large remaining available area 13 is not collected. And the processing time can be shortened.
Note that the threshold value of the processing termination is, for example, the CPU of the system.
It can be a value that changes according to the system operation status, such as the load status, and thereby controls the weight of the garbage collection process and the remaining available area 13 to be secured, thereby improving the efficiency of the entire computer system. it can.

Embodiment 4 Embodiment 4 of the present invention
Is a partial modification of the operation of the garbage collection process in the third embodiment. The basic configuration is the same as that of the third embodiment, and the description is omitted.

FIG. 10 is a flowchart showing the operation of the garbage collection process in the fourth embodiment.
This operation also repeats the partial garbage collection process similarly to the garbage collection process S140 in the third embodiment. However, unlike the procedure S140, the base pointer which is a list of the pointers 12 outside the heap area prior to the partial garbage collection process. Create a list.
That is, first, the appropriate pointer 1 outside the heap area 2
2 is selected (P1411), and if the pointer 12 is a valid value referring to the object area 10, (P1411)
1201), the value of the pointer 12 is stored in the base pointer list (S1501), and this procedure is repeated for all pointers 12 outside the heap area 2 (Yes in P1413, P1414).

Subsequently, the remaining available area 13 at the start of the processing is determined as the first TO area 15 (S1401), and the garbage collection processing has not yet been performed in the already acquired area 14 and the TO area T adjacent to 15
The region equal to or smaller than the O region 15
The OM area 16 is determined (S1402). In addition, FROM
When the area 16 is determined, similarly to the garbage collection processing of the third embodiment, even if all the object areas 10 included in the FROM area 16 are moved to the TO area 15,
To prevent the area 15 from overflowing, the FROM area 16
If there is an object area 10 that straddles the boundary, the object area 10 is excluded from the FROM area 16.
Next, a partial garbage collection process (partial GC process) is performed by roughly taking the following three stages. First of all,
From area 1 directly referenced by pointer 12 existing outside heap area 2 based on the base pointer list
6 is searched, and each object area 10 is moved to the TO area 15 by copying (S1).
51). Next, all the object areas 10 other than the FROM area 16 in the already acquired area 14 are searched, and the object areas 10 in the FROM area directly referred to from the object areas 10 are also searched for by TO.
Move to the area 15 (S141). Finally, TO area 1
5 is searched, and the object area 10 referenced from the corresponding object area 10 is also copied from the FROM area 16 to the TO area.
Move to area 15 (P162). Procedure P161, S1
According to 41 and P162, all object areas 10 that can be referred to directly or indirectly from the pointer 12 outside the heap area and the object area 10 existing in the already acquired area 14 other than the FROM area 16 can be referred to as the TO area 15
The object area 10 remaining in the FROM area 16 at this stage can be regarded as “garbage”. Partial garbage collection processing (S151, S141, P
162) is completed, the object area 10 in the TO area 15 is left uncopied and the empty FR
The OM area 16 is combined and redefined as a new remaining available area 13 (S1403). After that, if an unexecuted part of the partial garbage collection process remains in the already acquired area 14, the procedure proceeds to S1404. Returning to S1401, the partial garbage collection process is further repeated so that the garbage collection process is performed on the entire already acquired area 14.

Next, the details of step S151 will be described. In addition,
The details of the procedure S141 and the procedure P162 are described in Embodiment 3.
Since the details are the same as those in FIG. 8, the description is omitted.

In step S151, if a pointer is stored in the base pointer list (Yes in S1511)
s), the first element is selected from the stored pointers (S1512), and if the pointer 12 is valid and FROM
If the object area in the area 16 is referred to (Yes in S1513), the object area 10 referred to by the pointer 12 is moved to the TO area 15 by copying (P1612), and the element corresponding to the pointer 12 is set to the base pointer. It is deleted from the list (S1514). This procedure is repeated for all the pointers 12 held in the base pointer list (Yes in S1515, S15
16).

The fourth embodiment operates as described above and differs from the third embodiment in that the search for the pointer 12 outside the heap area 2 is not performed for each partial garbage collection process, but the entire garbage collection process is performed. Is performed only once, and if the reference destination of the pointer 12 is once subjected to the garbage collection processing, it is not subsequently inspected, and the search processing of the pointer 12 outside the heap area 2 is made more efficient, and the garbage collection processing is performed. Overall processing time can be reduced.

Note that, as in the third embodiment, the fourth embodiment
Also, by applying the existing technology for converting the stop-copy system to the incremental system, the system can be easily extended to the incremental system, and the constant response of the computer system can be improved. In addition, when the size of the remaining available area newly created when repeating the partial garbage collection process exceeds an appropriately determined threshold, the process is terminated, so that the overall garbage collection process is also shortened. be able to.

Embodiment 5 FIG. Embodiment 5 of the present invention
Is a detail of the operation of the garbage collection process in the third embodiment. The basic configuration is the same as that of the third embodiment, and the description is omitted. Further, the basic operation of the garbage collection process is the same as that of the third embodiment, and the description is omitted.

In the fifth embodiment, in the third embodiment, the memory acquisition means 3 operates so as to always acquire from the same one end of the remaining available area 13, and the partial garbage collection process repeated in the garbage collection process is performed by The divided F so as to conform to the above operation of the acquisition means 3
The ROM area 16 and the TO area 15 can be handled so that the remaining available area 13 always moves in one direction in the heap area 2 when the garbage collection process is repeated.

The specific operation of the fifth embodiment will be described with reference to FIG. FIG. 11 is an explanatory diagram showing the operation of the fifth embodiment. In the fifth embodiment, the memory acquisition unit 3 always acquires the object area 10 from the left of the remaining available area 13 in the figure. The previous G shown in FIG.
The state before the C processing indicates that the memory acquisition unit 3 has acquired the object area 10 from the left side in the figure with respect to the remaining available area 13 and the already acquired area 14 has grown. The stage in which the garbage collection process described in the fifth embodiment is performed once in this situation is the situation after the previous GC processing shown in FIG. The situation before the previous GC processing shown in FIG. 11 is equal to the situation before the processing shown in FIG. 9 showing the operation of the third embodiment, and the situation after the previous GC processing shown in FIG. 11 is shown in FIG. This is equivalent to the situation after the third partial GC process. The garbage collection process of the fifth embodiment operates in the same manner as in the third embodiment when the situation before the previous GC process shown in FIG. I do.

From the situation after the previous GC processing shown in FIG.
The stage at which the memory acquisition means 3 is called by the operation of the application program and a plurality of object areas are newly acquired is the situation before the current GC processing shown in FIG. In the situation after the previous GC shown in FIG.
Is located at the left end of the heap area 2 in the figure.
Since the memory acquisition means 3 always acquires the object area 10 from the left side of the remaining available area 13 in the figure, the already acquired area 14 also grows on the left end of the heap area 2 in the figure, and the current GC shown in FIG. In the state before the processing, the already acquired area 14 exists on both the left and right sides of the remaining available area 13 in the figure.

From the situation before the current GC processing shown in FIG.
A stage after the first partial garbage collection process in the garbage collection process in the fifth embodiment is a state after the first partial GC process shown in FIG.
FRO used for partial garbage collection at this stage
The amount of the M region 16 is set to be the same as that of the TO region 15 so as to be adjacent to the TO region 15 from the already acquired region 14 on the left side of the drawing with respect to the TO region 15. At this stage, the FROM area 16 has not reached the left end of the heap area 2 in the figure due to the size of the area, so the situation after the first partial GC processing shown in FIG. This is the result of the operation performed in such a manner that the right end in FIG.

From the situation after the first partial GC processing shown in FIG. 11, the stage where the second partial garbage collection processing in the garbage collection processing in the fifth embodiment is completed is the second partial GC processing shown in FIG. The latter situation. Unlike the previous area, the FROM area 16 used in the second partial garbage collection process is different from the TO area 15 only in the remaining available area 14 on the left side of the TO area 15 in the drawing.
Since the same amount of area cannot be secured, a FROM area 16 that compensates for the shortage from the right end of the TO area 15 is also set from the already acquired area 14 on the right side of the figure, and one continuous area is set. The partial garbage collection process is performed assuming the FROM area 16. As a result, 2 shown in FIG.
In the situation after the third partial GC processing, the newly set remaining available area 13, that is, the TO area 15 in the third partial garbage collection processing is divided into the left end and the right end of the heap area 2 in the figure.

From the situation after the second partial GC processing shown in FIG. 11, the stage where the third partial garbage collection processing in the garbage collection processing in the fifth embodiment is completed is the third partial GC processing shown in FIG. The latter situation. Since the TO area 15 used for the partial garbage collection processing at this stage exists in the heap area 2 at the right end and the left end in the drawing, the partial garbage collection processing is performed by regarding both as a continuous one TO area. . At this stage, since the already acquired area 14 which has not been subjected to the GC, which is the FROM area 16, does not remain much, in the situation of the third partial GC processing of FIG. , But depending on the amount of the “living” object area existing inside the FROM area 16, the TO
The operation is performed so as not to cover only the area 15 but also to the right TO area 15.

By operating as described above, the fifth embodiment operates as described above, whereby the time lapse has elapsed since the application program was acquired by the memory acquisition means 3 in the object area 10 always existing in the already acquired area 14. A smaller “young” object area 10 can be prioritized for garbage collection processing, and the efficiency of garbage collection processing is improved. Further, when the partial garbage collection process is repeated, the effect is improved by using this operation together with the operation of terminating the process when the size of the newly available remaining available area 13 exceeds an appropriately determined threshold.

In the fifth embodiment, the “young” object area 10 is subjected to the garbage collection processing with priority, but in the situation before the current GC processing in FIG. 11, the FROM area 16 in the first partial GC processing is used. To T
By setting from the already acquired area 14 on the right side adjacent to the O area 15 and setting similarly in the subsequent partial garbage collection processing, the “old” object area 10 is given priority in contrast to the fifth embodiment. Garbage collection processing can also be easily performed, thereby improving the efficiency of garbage collection processing for a program whose behavior related to the life of the object area 10 is different from a general application program.

Embodiment 6 FIG. Embodiment 6 of the present invention
Is a detail of the operation of the garbage collection process in the third embodiment. The basic configuration is the same as that of the third embodiment, and the description is omitted. Further, the basic operation of the garbage collection process is the same as that of the third embodiment, and the description is omitted.

The sixth embodiment is different from the third embodiment in that the remaining available area 1 is obtained by garbage collection processing.
Each time the memory 3 reaches the end of the heap area 2, the memory acquisition means 3
Operates to acquire from the different end of the remaining available area 13, and the partial garbage collection processing repeated in the garbage collection processing is performed by relocating the object area 10 from the FROM area 16 to the TO In the area 15, the memory is moved to the end opposite to the end obtained by the memory obtaining means 13, so that the remaining available area 13 is operated to reciprocate in the heap area 2 in the repetition of the garbage collection process. Things.

The specific operation of the sixth embodiment will be described with reference to FIG. FIG. 12 is an explanatory diagram showing the operation of the sixth embodiment. The situation before the previous GC processing shown in FIG. 12 indicates that the memory acquisition means 3 has acquired the object area 10 from the left side in the figure with respect to the remaining available area 13 and the already acquired area 14 has grown. The stage in which the garbage collection process described in the sixth embodiment is performed once in this situation is the situation after the previous GC processing shown in FIG. The situation before the previous GC processing shown in FIG.
The situation after the previous GC processing shown in FIG. 12 is equal to the situation before the processing shown in FIG.
This is equivalent to the situation after the third partial GC process shown in FIG. The garbage collection process according to the sixth embodiment is performed in a state before the previous GC process shown in FIG.
The operation is the same as in the third embodiment.

From the situation after the previous GC processing shown in FIG.
The stage at which the memory acquisition means 3 is called by the operation of the application program and a plurality of object areas 10 are newly acquired is the situation before the current GC processing shown in FIG. When the remaining available area 13 is at the right end of the heap area 2 in the figure, the memory acquiring means 3 of the sixth embodiment acquires the object area 10 from the left end of the remaining available area 13 in the figure, and conversely, When the available area 13 is at the left end of the heap area 2 in the figure, the operation is performed so as to acquire the object area 10 from the right end of the remaining available area 13 in the figure. Therefore, unlike the fifth embodiment shown in FIG. Previous G shown in 12
In the situation after the C processing, the remaining available area 13 is the heap area 2
In order to keep it on the left end in the figure,
Grows from the right end of the remaining available area 13 in the figure, and in the situation before the current GC processing shown in FIG.
3 exists so as to be in contact with the left end of the heap area 2 in the figure, and the already acquired area 14 exists so as to be in contact with the right end of the heap area 2 in the figure.

From the situation before the current GC processing shown in FIG.
The stage after the first partial garbage collection process in the garbage collection process in the sixth embodiment is the situation after the first partial GC process shown in FIG.
FRO used for partial garbage collection at this stage
The M area 16 is set to the same amount as the TO area 15 from the already acquired area 14 on the right side of the TO area 15 to the TO area 15 with respect to the TO area 15, whereby the first area GC processing shown in FIG. Is the result of operating simply by filling the FROM area 16 to the left end of the TO area 15 in the figure.

From the situation after the first partial GC processing shown in FIG. 12, the stage where the second partial garbage collection processing in the garbage collection processing in the sixth embodiment is completed is the second partial GC processing shown in FIG. The latter situation. The FROM area 16 used for the second partial garbage collection process is also set to the same amount as the TO area 15 so that the TO area 15 is adjacent to the TO area 15 from the already acquired area 14 on the right side of the drawing as in the previous time. As a result, the situation after the second partial GC processing shown in FIG.
The result is that the operation is performed in such a manner that the area 15 is shifted to the left end in the drawing.

From the situation after the second partial GC processing shown in FIG. 12, the stage where the third partial garbage collection processing in the garbage collection processing in the sixth embodiment is completed is the third partial GC processing shown in FIG. The latter situation. Also in the partial garbage collection process at this stage, the FROM area is set so that the TO area 15 is adjacent to the TO area 15 from the already acquired area 14 on the right side in FIG.
The area 16 is set, and thereby the second portion G shown in FIG.
Similar to the situation after the first partial GC processing, the situation after the C processing is a result of operating the unit FROM area 16 to the left end of the TO area 15 in the drawing.

By operating as described above, the sixth embodiment operates the application program by the memory acquisition means 3 at least after the last garbage collection process has been performed in the object area 10 existing in the already acquired area 14. By giving priority to the “young” object area 10 acquired by the garbage collection process, it is possible to simplify the operation of the garbage collection process compared to the fifth embodiment while maintaining the efficiency of the garbage collection process.

In the sixth embodiment, when the partial garbage collection process is repeated, the process may be terminated when the size of the newly created remaining available area 13 exceeds an appropriately determined threshold value, In the case where the application program can be operated during the garbage collection process, when the remaining available area 13 is moving from the right end to the left end of the heap area 2, the memory acquisition unit 3 starts from the left end of the remaining available area 13 When the object area 10 is acquired and the remaining available area 13 is moving from the left end to the right end of the heap area 2, the memory acquisition means 3 acquires the object area 10 from the right end of the remaining available area 13. By doing so, the same effect as in the sixth embodiment can be obtained.

Embodiment 7 FIG. Embodiment 7 of the present invention
Is a partial modification of the operation of the garbage collection process in the third embodiment. The basic configuration is the same as that of the third embodiment, and the description is omitted.

FIG. 13 is an overall flowchart showing the operation of the garbage collection process in the seventh embodiment. This operation also repeats the partial garbage collection process similarly to the garbage collection process S140 in the third embodiment. However, unlike the procedure S140, prior to the partial garbage collection process, first the size of the current remaining available area 13 is partially It is checked whether the garbage collection process is sufficient (S1601). If it is not enough (No in S1601), a compact partial garbage collection process (partial compact process) similar to the mark-compact method is performed and the remaining use is possible In order to expand the size of the area 13 (S161) and then perform the partial garbage collection processing, first, as in step S140, the remaining available area 13 at the start of the processing is determined as the first TO area 15 (S1401). Garbage collection among the already acquired areas 14 Not subject to down process, and defining a FROM area 16 the same amount or smaller area, the TO region 15 adjacent to the TO area 15 (S1402). When the FROM area 16 is determined, similar to the garbage collection process of the third conventional example, the FROM area 16 is set so that the TO area does not overflow even if all the object areas included in the FROM area 16 are moved to the TO area 15. If there is an object area 10 extending over the boundary of the area 16, the object area 10
Exclude from ROM area 16. Next, the following three stages are roughly performed, and the partial garbage collection processing (partial G
C process). First, for the CPU register of the computer, the memory area where the program is statically arranged, or all the pointers 12 existing outside the heap area 2 as variables in the stack, those pointers 12
The object area 10 in the FROM area 16 that is directly referred to from is searched, and each object area 10 is moved to the TO area 15 by copying (P161). Next, all the object areas 10 other than the FROM area 16 in the already acquired area 14 are searched, and the object areas 10 in the FROM area 16 directly referred to from the object areas 10 are also moved to the TO area 15. (S141). Finally, the object area 10 moved to the TO area 15 is searched, and the object area 10 referred to by the corresponding object area 10 is also moved from the FROM area 16 to the TO area 15 by copying (P162). By the procedures P161, S141, and P162, all object areas 10 that can be directly or indirectly referenced from the pointer 12 outside the heap area and from the object area 10 other than the FROM area 16 in the already acquired area 14 are stored in the TO area 15. Because it moved
Object area 10 remaining in FROM area 16 at this stage
Can be regarded as “garbage”. When the partial garbage collection process (P161, S141, P162) ends, the remaining area of the TO area 15 where the object area 10 is not copied and the empty FROM area 16 are combined to define a new remaining available area 13. Fix (S1
403) Then, if there is an unexecuted portion of the partial garbage collection process in the already acquired area 14 (S403).
(Yes in 1404), the process returns to step S1401, and the partial garbage collection process is further repeated so that the garbage collection process is performed on the entire already acquired area 14. If there is sufficient remaining available area 13 at the start of the garbage collection process, the process directly proceeds to step S1401 without performing step S151.

Procedure P161, Procedure S141, Procedure P16
The details of 2 are the same as the details in the third embodiment (FIG. 8), and thus the description is omitted.

Next, details of the partial garbage collection processing (partial compact processing) by the compact method shown in step S161 will be described. FIG. 14 is a flowchart of a partial compact process showing the operation of the garbage collection process in the seventh embodiment. In this operation, first, the remaining available area 13 at the start of the processing is set to the first TO area 15.
(S1401), the TO of the already acquired area 14
An appropriate size adjacent to the area 15 is determined as the FROM area 16 (S1611). The partial compact processing S1
The size of the remaining available area 13 obtained after the execution of 61 is included in the FROM area 16 from the sum of the size of the TO area 15 determined in step S1401 and the size of the FROM area 16 determined in step S1611. The total amount of the "living" object area 10 is reduced. Therefore, the size of the FROM area 16 determined in step S1611 is
In association with the determination of whether the size of the current remaining available area 13 in step S1601 in FIG. 13 is sufficient to perform the partial garbage collection process, it is appropriate to perform the partial garbage collection process after the completion of the partial compact process S161. It should be an appropriate size that can be expected to obtain a good value.

Next, the following three steps are taken, and F
"Living" object area 1 in ROM area 16
Extract 0. First, the computer's CPU register,
With respect to all the pointers 12 existing outside the heap area 2 as variables in the memory area or the stack statically allocated by the program, the object area 10 in the FROM area 16 directly referred to by the pointers 12 is searched. If there is an undetected object area 10, the object area 10 is added to the valid object area list (S162). Next, already acquired area 1
4, all object areas 10 other than the FROM area 16 are searched, and those object areas 10 are searched.
Also, if the object area 10 in the FROM area directly referred to from is not detected, the object area 10 is added to the effective object area list (S163). Finally, the effective object area list is searched, and the object area 10 in the FROM area 16 referenced from the object area 10 in the effective object area list is added to the effective object area list if not detected (S16).
4). In steps S162, S163, and S164, the object area 1 existing from the pointer 12 outside the heap area and from the already acquired area 14 other than the FROM area 16
Since all the object areas 10 that can be referred to directly or indirectly from 0 are registered in the valid object area list, the object areas 10 that are present in the FROM area 16 at this stage and are not registered in the valid object area list are “garbage”. ] Can be considered. When the extraction of the “living” object area 10 in the FROM area 16 (S162, S163, S164) is completed, all the object areas 10 registered in the valid object area list are replaced with the TO area 15 and the FROM area 16
Is moved by copying so that the TO area 16 is packed first from the TO area 16 side (S1612), and then the area vacated by the movement is redefined as a new remaining available area 13 (S1613).

Next, details of steps S162, S163 and S164 will be described.

In step S162, one of the appropriate pointers 12 outside the heap area 2 is selected (P141).
1) If the pointer 12 is valid and refers to the undetected object area 10 in the FROM area 16 (Yes in S1621), the object area 10 referred to by the pointer 12 is additionally registered in the valid object area list. (S1622), this procedure is repeated for all pointers 12 outside the heap area 2 (P1413)
Yes, P1414).

In step S163, if there is an object area 10 other than the FROM area 16 in the already acquired area 14 (Yes in S1411), one corresponding object area 10 is selected first (S1412), and the selected object area 10 is selected. If 10 includes a pointer 12 inside (P1
313, Yes), first, the selected object area 10
Is selected (P1314),
If the value is valid and refers to the undetected object area 10 in the FROM area 16 (Yes in S1621)
s), the object area 10 of the reference destination is additionally registered in the effective object area list (S1622), and this procedure is repeated for all the pointers 12 included in the selected object area 10 (No in P1315). The above procedure is repeated for all the object areas 10 in the acquired area 14 other than the FROM area 16 (No in S1413).

In step S164, if there is an unprocessed object area 10 in the valid object area list (S1
641), and first selects one corresponding object area 10 from the effective object area list (S16).
42), if the selected object area 10 includes the pointer 12 inside (Yes in P1313), first, one of the pointers 12 included in the selected object area 10 is selected (P1314), and the value is valid and the FROM area 16 is selected.
If an undetected object area 10 within the object is referred to (Yes in S1621), the object area 10 of the reference destination is additionally registered in the valid object area list (S1).
622), this procedure is repeated for all the pointers 12 included in the selected object area 10 (P
1315), and the above procedure is repeated for all the object areas 10 registered in the valid object area list (No in S1643).

The specific operation of the seventh embodiment will be described with reference to FIG.

FIG. 15 is an explanatory diagram showing the operation of the seventh embodiment. In the state before the processing shown in FIG. 15, the remaining available area 13 is set to T in the partial compact processing S161.
An O area 15 (S1401) is shown, and an appropriate amount of an area adjacent to the TO area 15 in the already acquired area 14 is set as the FROM area 16 in the partial compact processing S161 (S1611). FR for this situation
"Living" object area 10 in OM area 16
Is extracted (S162, S163, S164),
FIG. 16 shows a state after searching for an effective object shown in FIG. 15. Further, in response to this situation, all the object areas 10 registered in the effective object area list are
To the area where the O area 15 and the FROM area 16 are combined, TO
Move by copy so that area 15 side is packed first (S
1612) is the situation after the partial compact processing shown in FIG.

As described above, in the seventh embodiment, when the remaining available area 13 before the start of the garbage collection process is small, a partial compact process is performed to increase the remaining available area 13 in advance, and then the third embodiment is performed. By performing the garbage collection process shown as,
Remaining available area 13 before garbage collection processing starts
Is small, it is possible to avoid the problem that the number of repetitions of the partial garbage collection process increases, and it is possible to increase the efficiency of the garbage collection process.

In the seventh embodiment, in the partial compact processing S162, the valid object area list is used to extract the "living" object area 10 in the FROM area 16, and thereafter the "living" object area is used. Are combined into one, but the procedure S
Instead of the system shown in FIG. 162, for example, the mark-compact system shown in the fourth conventional example, or an improved system thereof may be used, and the same effect can be obtained.

In the seventh embodiment, the partial compact processing S162 is performed only once. However, the same effect can be obtained by repeating the processing until the appropriate remaining available area 13 is obtained. And the entire garbage collection process can be partially compacted in step S16.
It may be performed by repeating only 2.

Further, the seventh embodiment is different from the third embodiment.
Similarly, by applying the existing incremental system technology, the system can be easily expanded to the incremental system, and the constant response of the computer system can be improved.

Further, in the seventh embodiment, as in the third embodiment, the partial compact processing S162 and the partial garbage collection processing (S1401 to S14 in FIG. 13) are performed.
Since the processing is highly independent between the transition of the processing of step 04) and the repetition of the processing, the garbage collection processing is temporarily suspended in these parts to perform the operation of the application program, and the operation of the application program by the garbage collection processing is performed. It is easily possible to reduce the interruption time.

In the seventh embodiment, as in the third embodiment, the partial compact processing S162 and the partial garbage collection processing (S1401 to S140 in FIG. 13) are performed.
In the process transition and repetition of the process 4), the process is terminated when the size of the newly available remaining area 13 exceeds an appropriate threshold, thereby shortening the entire garbage collection process. Can be.

Embodiment 8 FIG. FIG. 16 is a configuration diagram showing a basic configuration of the eighth embodiment of the present invention. In FIG. 16, heap area 2, object area 10, pointer 1
2 is the same as FIG. 7, and the description is omitted. Further, the dynamic memory management mechanism 1, the memory acquisition means 3, the memory release means 4, and the garbage collection means 5 are not important for the description of the operation of the eighth embodiment, and their descriptions are omitted. The reference table 17 is a table that holds a reference to each object area 10 in the heap area 2, and exists outside the heap area 2.

Next, the operation of the eighth embodiment will be described.
In the eighth embodiment (FIG. 16), unlike the third embodiment (FIG. 7), the pointer 12 does not directly refer to the object area 10 but always refers to the object area 10 via the entry of the reference table 17. I do. Lookup table 17
Is associated with the object area 10 by the memory acquisition means 3 that generates the object area 10. As long as the object area 10 exists, even if the object area 10 is “live”, “garbage” In this case, the association is unchanged, and the association is lost by the memory releasing means 4 for releasing the object area 10. In addition, the object area 1 is added to the garbage collection
When the position of 0 moves, the contents of the entry of the reference table 17 are updated so that the corresponding object area 10 can be correctly referred to. On the other hand, pointer 1
2 is information necessary for reference to the object area 10,
The information is stored as information for specifying an entry in the reference table 17. When referring to the object area 10 from the pointer 12, the entry of the reference table 17 is always specified based on the information held by the pointer 12, and the corresponding object area 10 is specified based on the information held by the corresponding entry.
It is performed in a form to arrive at.

In the eighth embodiment, the reference table 17 is an array of entries, and the pointer 12 is the reference table 1
Subscript (integer value) of array to specify entry in 7
, And the entry of the reference table holds the start address of the corresponding object area 10 in the memory area. In FIG. 16, a pointer Rp outside the heap area 2 referring to the object area A and a pointer Bp1 inside the object area B both have the same value so as to point to the same entry associated with the object area A in the reference table 17. Holds the subscript of the array of entries. Similarly, the pointer Ap2 in the object area A that refers to the object area B holds a suffix of the corresponding entry array so as to point to the entry associated with the object area B in the reference table 17. Pointer Bp2 in object area B holding an invalid value
Holds a subscript of the array of the entry so as to point to a special entry for indicating an invalid value in the lookup table 17. When the arrangement position of the object area 10 in the memory area is changed by the garbage collection process, only the address value held by the corresponding entry of the reference table 17 is changed, and the value of the pointer 12 is not changed.

According to the eighth embodiment, the operation as described above allows the object area 10 to be moved by the garbage collection process as in the sixth conventional example.
Since the adjustment process of the pointer 12 pointing to the object area 10 can be simplified, and unlike the sixth conventional example, the reference table 17 is independent of the heap area 2, the fourth conventional example is shown. It can be combined with the mark-compact method or the garbage collection method in which the area before the movement is destroyed when the object area 10 is moved, such as the partial compact processing (S161) in the seventh embodiment. Further, since all the existing object areas 10 are registered in the reference table 17, the search of the object area 10 is facilitated by using the reference table 17 in the garbage collection processing. Frequent access to the small reference table 17 improves the operation efficiency of the virtual address translation cache and the memory cache in the computer system, thereby increasing the processing speed of the garbage collection process.

Reference table 17 in the eighth embodiment
Should be large enough to hold at least the entries corresponding to all the object areas 10 that exist simultaneously in the heap area 2. Considering the maximum number of the object areas 10 that can exist simultaneously in the heap area 2, May be determined according to the size of the heap area, or may be dynamically changed according to the number of object areas 10 existing in the heap area 2.

In the eighth embodiment, the pointer 12
Holds the subscript (integer value) of the array to indicate the entry of the reference table 17, but the same effect can be obtained by holding the arrangement address of the entry. Further, in the eighth embodiment, a special entry dedicated to the reference table 17 is provided in order to indicate an invalid value with the pointer 12, but this is because the reference table 17 has an entry that refers to the valid object area 10. And only the pointer 12 has a special value,
For example, a reference table 1 such as a negative value for a subscript of an array or 0 to NULL for an arrangement address
The same effect can be obtained by holding an inappropriate value for designating the 7th entry.

Further, in the eighth embodiment, the reference table 17 is assumed to exist outside the heap area 2. The same effect can be obtained by separately securing the object area 10 or securing it as one of the object areas 10 that is never released. For the same reason, instead of constructing the reference table 17 as one continuous table, it may be composed of a plurality of sub-tables.
The same effect can be obtained even if an arbitrary structure corresponding to, for example, a tree structure is adopted.

Embodiment 9 FIG. Embodiment 9 of the present invention
Relates to the operation timing of the application program and the garbage collection process. The basic configuration is the same as that of the third embodiment, and the description is omitted.

FIG. 17 is a flowchart showing the operation of the ninth embodiment. The garbage collection process (GC process) S200 in the ninth embodiment is roughly composed of the following three stages, a pre-process S201, a repeated unit process S202, and a post-process S203. After performing pre-processing S201 as a preparation before entering, the GC operation availability flag is checked (S2001). If the value is true, that is, if garbage collection processing can be continued (Yes in S2001), garbage collection is performed. The repetition process S202 is executed for one unit process,
Thereafter, if it is necessary to continue the repetitive processing (S
(No in 2002), while the GC operation availability flag is true (S2
(Yes of 001) Whether the repetition process S202 is repeated and the repetition process S202 does not need to be performed (S200)
(Yes of 2), if the GC operation availability flag is false and the garbage collection process cannot be continued (S20)
(No of 01), post-processing S203 is performed as an end of the repetition processing S202 of the garbage collection processing, and the processing ends.

Next, steps S201, S202, S203
The details are shown below. Although the specific processing contents of steps S201, S202, and S203 differ depending on the garbage collection processing, first, in the case where the garbage collection processing described in the third embodiment is used, the details of steps S201 and S203 are empty. The processing is performed, and details of the procedure S202 are described in S1401, S1402, S161, and S1 in FIG.
41, S162, S1403, and S1404. Further, in the case where the garbage collection processing described in the fourth embodiment is based, details of the procedure S201 are described in FIG.
S105, P141, P1201, P1501, P1
413 and P1414, and details of the procedure S203 are described in S1401, S1402, S151, S151 in FIG.
The procedures are 141, S162, S1403, and S1404, and the details of the procedure S203 are empty. The process shown in the step S202 must be a process that can be repeated an arbitrary number of times from zero to the maximum, and the memory acquisition unit 3 and the memory release The occurrence of internal inconsistency in any of the means 4 or the garbage collection means 5 or a plurality of means is not allowed.

Next, the operation of the ninth embodiment will be described with reference to FIG.
8 will be described. FIG. 18 is an explanatory diagram showing the operation of the ninth embodiment, and the application program has an appropriate period T1.
, And the GC operation availability flag is controlled to periodically change to become true in synchronization with the start of the application program, and then to become false after a certain time T2 shorter than T1. The garbage collection process S200
Is given an opportunity to operate simultaneously with the application program,
If both can operate at the same time, control is performed so that the application program operates prior to the garbage collection process.

In the ninth embodiment, as described above, the garbage collection process S200 is performed during the time T2 from the operation trigger of the application program and the operation of the application program is interrupted, or the operation of the application program is terminated. Is controlled so that it can be operated only when the operation is performed, T2 / T1 (<1) at the maximum (exactly (T2 + procedure S2)
Since the processing can be restricted so that the processing is performed only up to the ratio of (execution time 02) / T1), the operation of the computer system is stabilized, and the garbage collection processing is always completed at the next operation of the application program. Therefore, the constant response of the computer system can be improved without hindering the periodic operation of the application program.

In the ninth embodiment, the procedure S2
01, S202, and S202, even if it is not possible to perform the processing of the application program by giving priority to the processing of the application program in the middle, for example, as described in the description of the third embodiment, By suspending the garbage collection process between these processes and allowing the application program to operate, even if the garbage collection process operates once during the execution of the application program, the interruption time can be reduced, and the computer system Can be improved.

In the ninth embodiment, the operation of the garbage collection process S200 is provided at the same time as the operation of the application program. However, this operation is performed after the operation of all the application programs operating in the cycle T1 is completed. An operation trigger to the garbage collection process S200 may be given. In this case, the processing of the application program can be performed with higher priority, and the responsiveness of the operation of the application program can be further improved.

Embodiment 10 FIG. Embodiment 1 of the present invention
0 relates to the operation timing of the application program and the garbage collection process. The basic configuration is the same as that of the third embodiment, and the description is omitted.

FIG. 19 is a flowchart showing the operation of the tenth embodiment. The garbage collection process (GC process) S210 in the tenth embodiment is roughly the same as the ninth embodiment in the following three stages, a pre-process S20.
1. Repeated unit processing S202, post processing S203
First, as a preparation before entering the repetition processing S202 of the garbage collection processing, a pre-processing S2
01, the GC operation availability counter is checked (S2
101), if the value is larger than 0 and the garbage collection process can be continued (Ye in S2101)
s), garbage collection processing repetition processing S20
2, the value of the GC operation availability counter is decremented by 1 (S2102), and if it is necessary to continue the repetition processing (No in S2002), the value of the GC operation availability counter is greater than 0. Interval (Y in S2001)
es) Is it unnecessary to repeat the repetition process S202 and perform the repetition process S202 (Yes in S2002)
s) If the value of the GC operation availability counter is 0 or less and the garbage collection process cannot be continued (S2)
(No in 001), the post-processing S203 is performed as an end of the repetition processing S202 in the garbage collection processing, and the processing ends.

The details of steps S201, S202, and S203 are the same as those in the ninth embodiment, and thus description thereof is omitted.

Next, the operation of the tenth embodiment will be described with reference to FIG. FIG. 20 is an explanatory diagram showing the operation of the tenth embodiment. The application program operates periodically at an appropriate period T1, and the GC operation availability counter adds an appropriate constant value in synchronization with the start of the application program. Is done. The value to be added to the GC operability counter is such a value that the garbage collection process S210 ends by the next operation of the application program even if the garbage collection process S210 is performed after the application program process is prolonged. And The garbage collection process S21
0 indicates that the value of the GC operation availability counter has become 0 or less (S
Therefore, the repetition of the repetition process S202 is not necessary (S2002).
(Yes), the value of the GC operation availability counter becomes a value larger than 0, but this value is not returned to 0, and a certain value is added at the next opportunity. However, if the value of the GC operation availability counter after the addition is too large, the value is appropriately adjusted. The garbage collection process S210
Is given an opportunity to operate simultaneously with the application program,
If both can operate at the same time, control is performed so that the application program operates prior to the garbage collection process S210.

In the tenth embodiment, as described above, the garbage collection process S210 is performed in the G of the application program.
Since the control is performed so that the operation is possible only while the C operation availability counter is greater than 0 and the operation of the application program is interrupted or the operation of the application program is terminated, the GC operation availability counter is controlled every time. By appropriately selecting the increase value, the process of the garbage collection process S210 can be completed by the time of the next application program operation. As in the ninth embodiment, the periodic operation of the application program is not hindered. In the tenth embodiment, the processing time allocated to the garbage collection process S210 can be kept more constant in each cycle than in the ninth embodiment, so that the operation of the application program is prolonged. In this case, the garbage collection process S210 can be operated longer than in the ninth embodiment. Therefore, more and more of it is the recovery of the "garbage", memory utilization efficiency is improved.

In the tenth embodiment, similarly to the ninth embodiment, during execution of each of the steps S201, S202, and S202, the processing of the application program is prioritized in the middle of the processing of the application program. Even when the application program cannot be executed, for example, as described in the description of the third embodiment, if the garbage collection process is paused between the processes so that the operation of the application program can be performed, the garbage collection is temporarily performed during the execution of the application program. Even if the collection process operates, the interruption time can be kept short, and the constant response of the computer system can be improved.

In the tenth embodiment, the operation of the garbage collection process S210 is given at the same time as the operation of the application program. However, similarly to the ninth embodiment, this is applied to all the applications operating in the cycle T1. Garbage collection processing S after the operation of the program ends
An operation trigger to 210 may be given. In this case, the processing of the application program can be performed with higher priority, and the responsiveness of the operation of the application program can be further improved.

Further, in the tenth embodiment, an integer value is used for the GC operation availability counter. However, this value is used to represent the time. In step S2102, the execution time of S202 is subtracted from the GC operation availability counter. You may do
In this case, the time allocated to the garbage collection process S210 can be more strictly controlled.

Embodiment 11 FIG. Embodiment 1 of the present invention
Reference numeral 1 relates to the operation timing of the application program and the garbage collection process, which is an improvement of the tenth embodiment. The basic configuration is the same as that of the third embodiment, and the description is omitted.

FIG. 21 is a flowchart showing the operation of the eleventh embodiment. The garbage collection process (GC process) S220 in the eleventh embodiment is roughly the following three stages, the pre-process S2, as in the tenth embodiment.
01, repeated unit processing S202, post processing S20
First, in the garbage collection process, a pre-processing S
After performing step 201, it is checked whether the current remaining available area 13 is sufficiently obtained (S2201). If it is enough (Yes in S2201), the GC operation availability counter is checked (S2101). If the value is larger than 0 and the garbage collection process can be continued (S21)
01 (Yes), the repetition process S202 of the garbage collection process is executed for one unit process. In the determination of the amount of the remaining available area 13 in step S2201, the determination is made based on at least the amount that needs to be secured in the periodic garbage collection process S220 based on the operation behavior of the application program. S
If the current remaining available area 13 is not sufficiently obtained in 2201, the procedure S2101 is omitted, and the process immediately proceeds to the repetition processing S202 of the garbage collection processing. After that, first, the value of the GC operation availability counter is reduced by 1 (S21).
02) Then, if it is necessary to continue the repetitive processing further (No in S2002), whether the remaining available area 13 has not been sufficiently collected (No in S2201) or G
While the C operation availability counter is greater than 0 (Y in S2001)
es), is it unnecessary to repeat the repetition process S202 and perform the repetition process S202 (Yes in S2002)
s) If the remaining available area 13 is sufficiently obtained (Yes in S2201), and the value of the GC operation availability counter is 0 or less and the garbage collection process cannot be continued (No in S2001), the garbage collection process is not performed. Post-processing S2 as the end of the repetition processing S202
03, and the process ends.

The details of steps S201, S202, and S203 are the same as those in the ninth and tenth embodiments, and a description thereof will not be repeated.

Next, the operation of the eleventh embodiment will be described with reference to FIG. FIG. 22 is an explanatory diagram showing the operation of the eleventh embodiment. The application program operates periodically at an appropriate period T1, and the GC operation availability counter adds an appropriate constant value in synchronization with the start of the application program. Is done. The value to be added to the GC operability counter is a value such that even if the garbage collection processing S220 is performed after the application program processing is prolonged, the garbage collection processing S220 ends by the next operation of the application program. And Also, the processing of the garbage collection S210 is not terminated because the value of the GC operation availability counter has become 0 or less (No in S2101), and the repetition of the repetition processing S202 is no longer necessary (S20).
If the process is terminated because of Yes of 02), the value of the GC operation availability counter becomes a value larger than 0, but this value is not returned to 0, and a certain value is added at the next opportunity. However,
If the value of the GC operation availability counter after the addition is too large, it is adjusted appropriately. Similarly, garbage collection processing S
In the case where the process 220 is terminated without being able to collect a sufficient remaining available area 13 easily, the value of the GC operation availability counter is set to 0.
The value may be smaller, but this value is not returned to 0, and a constant value is added at the next opportunity. However, also in this case, if the value of the GC operation availability counter after the addition is too small, the value is appropriately adjusted. In the garbage collection process S220, an operation opportunity is given at the same time as the application program. However, when both can operate at the same time, control is performed so that the application program operates with priority over the garbage collection process S220.

In the eleventh embodiment, as described above, the garbage collection process S220 is performed when the operation of the application program is interrupted or the operation of the application program is terminated and the minimum remaining available Since the area 13 can be collected and the operation is controlled so as to operate only while the GC operation availability counter of the application program is larger than 0, the next application program can be selected by appropriately selecting the increment value of the GC operation availability counter each time. The processing of the garbage collection process S220 can be completed by the time of the operation of, and the periodic response of the application program is not hindered and the constant response of the computer system can be improved as in the ninth and tenth embodiments. Furthermore, in the eleventh embodiment, as in the tenth embodiment, the processing time allocated to the garbage collection process S220 can be kept more constant in each cycle than in the ninth embodiment, so that the operation of the application program is prolonged. Since the garbage collection process S220 can be operated longer than in the ninth embodiment, more “garbage” can be collected and the memory use efficiency can be improved. In addition, in the eleventh embodiment, as compared with the tenth embodiment, an operation is performed so as to secure at least a fixed amount of the remaining available area 13 in each cycle. Failure to secure the object area 10 of the memory acquisition means 3 due to the above, the operation of the application program becomes stable,
In addition, when the garbage collection process S220 is prolonged, an operation is performed to shorten the next process, so that the operation of the entire computer system is stabilized.

In the eleventh embodiment, as in the ninth and tenth embodiments, steps S201 and S2 are performed.
02 and S202, even if it is not possible to prioritize the processing of the application program and perform the processing of the application program on the way, for example, in the third embodiment.
As described in the description of the above, if the garbage collection process is paused between those processes so that the application program can operate, even if the garbage collection process operates once during the execution of the application program, the interruption time is reduced. It can be kept short, and the constant response of the computer system can be improved.

In the eleventh embodiment, the operation trigger of the garbage collection process S220 is given at the same time as the operation trigger of the application program. However, similarly to the ninth and tenth embodiments, this operation is performed at the cycle T1. An operation trigger to the garbage collection process S220 may be given after the operation of all running application programs is completed. In this case, the processing of the application programs can be performed with higher priority, and The responsiveness of the operation can be further improved.

Further, in the eleventh embodiment, an integer value is used for the GC operation availability counter.
0, G is used in step S2102 by using a value representing the time.
The execution time of S202 may be subtracted from the C operation availability counter. In this case, the time allocated to the garbage collection process S220 can be more strictly controlled.

Embodiment 12 FIG. Embodiment 1 of the present invention
2 will be described with reference to the drawings. FIG. 23 is a block diagram showing a configuration of a dynamic memory management mechanism according to Embodiment 12 of the present invention.
In FIG. 23, dynamic memory management mechanism 1, heap area 2, garbage collection means 5, object area 1
0, the pointer 12, the remaining available area 13, and the already acquired area 14 are the same as those in the third embodiment of FIG. The available memory area in the remaining available area 13 is managed by the free list 18, and the object area 10 is acquired by allocating an appropriate area in the free list 18 by the memory acquiring means 3, and the acquired object The area 10 constitutes a part of the already acquired area 14. Further, the object area 10 is released by being returned to the free list 18 by the memory releasing means 4, and the area can be reused.

Next, the operation of the twelfth embodiment will be described. FIG. 24 is an overall flowchart showing the operation of the garbage collection process (GC process) in the twelfth embodiment. The garbage collection process according to the twelfth embodiment operates differently depending on the activation trigger, and when the activation trigger is activated, the memory acquisition unit 3 operates the application program while the application program is running due to a shortage of the remaining available area 13. If the area 10 has not been acquired (left branch in S2301 in the drawing), first, a non-copy-type partial garbage collection process is performed on a part of the already acquired area 14 and the free area in the remaining available area 13 is obtained. Attempt to expand the list 18 (S231), and if the necessary object area 10 can be secured (S2)
302 (Yes in 302), and if the necessary object area 10 cannot be secured by only step S231 (S2).
302), the necessary object area 10 is determined in the same manner as the procedure 1612 in the seventh embodiment (FIG. 14).
Then, the effective object area 10 is moved by copying so that the available memory areas can be secured, and a plurality of available memory areas in the free list 18 are collected into a single memory area (S232). On the other hand, this garbage collection processing S2
In the case where the activation trigger of 30 is a regular operation as shown in the ninth embodiment (right branch in the drawing of S2301), for example, the garbage collection process of the stop-copy method shown in the fifth conventional example, or A copy-type garbage collection process such as the garbage collection process described in the third to ninth embodiments is performed to expand the remaining available area 13 (S233).

Next, details of the non-copy type partial garbage collection process (non-copy type partial GC process) for a part of the already acquired area 14 shown in step S231 will be described. FIG. 25 is a flowchart of a non-copy-type partial garbage collection process showing the operation of the garbage collection process in the ninth embodiment. In this operation, first, an appropriate size of the already acquired area 14 is determined as the FROM area 16 (S2311), and all object areas in the FROM area 16 are temporarily connected to the free list 18 (S2312). Next, the “living” object area 10 in the FROM area 16 is extracted and removed from the free list 18 through the following three steps.
Next, with respect to all the pointers 12 existing outside the heap area 2 as variables in the CPU register of the computer, the memory area statically allocated by the program, or the stack, the FRO directly referred to by the pointers 12 is used.
The object area 10 in the M area 16 is searched, and if there is an undetected object area 10, the object area 10 is removed from the free list 18 and added to the valid object area list (S235). Next, all the object areas 10 other than the FROM area 16 in the already acquired area 14 are searched, and those object areas 1 are searched.
The object area 10 in the FROM area 16 which is directly referred to from 0
If so, the object area 10 is stored in the free list 18
And adds it to the valid object area list (S2
36). Finally, the valid object area list is searched, and the object list 10 in the FROM area 16 referred to from the object areas 10 in the valid object area list is also detected in the free list 1 if not detected.
8 and added to the valid object area list (S2
37), end the processing. Procedures S235, S236, S
In accordance with 237, all object areas 10 that can be directly or indirectly referred to from the pointer 12 outside the heap area and the object area 10 existing in the acquired area 14 other than the FROM area 16 are removed from the free list 18 and the effective object area list Since registered
At this stage, the object area 10 existing in the FROM area 16 and not registered in the valid object area list and still connected to the free list 18 can be regarded as “garbage”.

Next, details of step S235, step S236, and step S237 will be described.

In step S235, first, one of the appropriate pointers 12 outside the heap area 2 is selected (P141).
1) If the pointer 12 is valid and refers to the undetected object area 10 in the FROM area 16 (Yes in S1621), the object area 10 referred to by the pointer 12 is removed from the free list 18 and the valid object area This procedure is additionally registered in the list (S2351), and this procedure is repeated for all pointers 12 outside the heap area 2 (Yes in P1413, P1414).

In step S236, if there is an object area 10 other than the FROM area 16 in the already acquired area 14 (Yes in S1411), one corresponding object area 10 is selected first (S1412), and the selected object area 10 is selected. If 10 includes a pointer 12 inside (P1
313, Yes), first, the selected object area 10
Is selected (P1314),
If the value is valid and refers to the undetected object area 10 in the FROM area 16 (Yes in S1621)
s), a free list 1 of the referenced object area 10
8 and is additionally registered in the valid object area list (S2351), and the object area 1 in which this procedure is selected
0 is repeated for all the pointers 12 included in the area 0 (No in P1315), and the object area 10 in the acquired area 14 other than the FROM area 16
The above procedure is repeated for all of the steps (N in S1413)
o).

In step S237, if there is an unprocessed object area 10 in the valid object area list (S1
641), and first selects one corresponding object area 10 from the effective object area list (S16).
42), if the selected object area 10 includes the pointer 12 inside (Yes in P1313), first, one of the pointers 12 included in the selected object area 10 is selected (P1314), and the value is valid and the FROM area 16 is selected.
If an undetected object area 10 is referred to (Yes in S1621), the reference target object area 10 is removed from the free list 18 and added to the valid object area list (S2351), and this procedure is selected. This is repeated for all the pointers 12 included in the object area 10 (No in P1315), and the above procedure is repeated for all the object areas 10 registered in the valid object area list (S1).
No. 643).

As described above, in the twelfth embodiment, the content of the garbage collection process S230 is changed in response to the activation of the garbage collection process S230. Due to lack of memory, the memory acquisition means 3 operates the application program and the amount of object area 1 requested by the application program is reduced.
In the case where 0 cannot be acquired, the application program operates so that the interruption time of the application program is shortened as much as possible. The possible memory area is made to be a continuous area as large as possible, and the operation is performed so that the interruption of the application program is less likely to occur, whereby the responsiveness of the operation of the application program can be improved.

In the twelfth embodiment, when the remaining available area 13 is insufficient during the operation of the application program, the third
The non-copy type partial garbage collection process S231 according to the mark-sweep method shown in the conventional example of the prior art is performed, and then in step S232, the available memory areas in the free list 18 are combined into a single area. ,
Any garbage collection method can be used as long as the remaining available area 13 enough to obtain the required object area can be secured quickly. For example, a mark-sweep method instead of step S231, or The same effect can be obtained by partially or entirely using another similar method to the already acquired area 14, and further, the procedure S231 and the procedure S232 are summarized, for example, in the seventh embodiment (FIGS. 13 and 14). The same effect can be obtained by substituting the partial compact processing S161 in, or the mark-compact garbage collection processing shown in the fourth conventional example. Similarly, the processing at the time of the periodic operation of the twelfth embodiment is as follows.
Any garbage collection method can be used as long as the remaining available area 13 can be efficiently collected as much as possible. Furthermore, by using the garbage collection process of the reference counter method as shown in the first or second conventional example or the first or second embodiment in combination with the twelfth embodiment, the application program can be operated. The occurrence of the shortage of the remaining available area 13 in the inside can be further suppressed.

Embodiment 13 FIG. Embodiment 1 of the present invention
No. 3 shows that the garbage collection process operates differently depending on the condition of the activation trigger under different conditions from the twelfth embodiment. The basic configuration is the first embodiment.
Since the configuration is the same as that of the second embodiment, the description is omitted.

FIG. 26 is a flowchart showing the operation of the thirteenth embodiment. The garbage collection process (GC process) S240 in the thirteenth embodiment operates differently depending on the state of the activation trigger, and is acquired by the memory acquisition unit 3 from the time when the garbage collection process was last performed to the time when the current activation. If the number of object areas 10 is small (left branch in S2401 in the figure), the stop-copy type garbage collection process shown in the fifth conventional example is performed (S241), and on the other hand, memory is acquired by the time of this activation. If the number of object areas 10 acquired by the means 3 is large (right branch in S2402 in the figure), the garbage collection process of the mark-sweep method shown in the third conventional example is performed (S242).

As shown in the third and fifth conventional examples,
In the stop-copy method, the fragmentation phenomenon which is a problem of the mark-sweep method can be avoided. However, since the copy operation of the object area is included in the processing, the mark-sweep method is used when the same number of object areas are handled. There is a problem that processing time becomes long. However, in the thirteenth embodiment, as described above, the two are selectively used depending on the state at the time of the start of the garbage collection process S240, so that the processing time required for the garbage collection process is newly acquired after the previous garbage collection process. Irrespective of the number of the object areas 10, the stop-copy method is appropriately performed while keeping the object area 10 as constant as possible, so that the occurrence of the fragmentation phenomenon can be avoided, and the operation of the computer system can be stabilized.

In the thirteenth embodiment, which garbage collection method is used is determined based on the number of object areas 10 newly acquired after the previous garbage collection process. However, this determination is fixed. The same effect can be obtained even if the threshold value is adaptively determined based on the past history, for example, instead of the determination based on the appropriate threshold value. In addition, regarding the object area 10 newly acquired after the previous garbage collection process, not only the number of the object area 10 but also the total amount thereof may be used for the determination, or the object area 10 newly acquired after the previous garbage collection process may be used. However, the same effect as that of the thirteenth embodiment can be obtained by using an index related to the object area 10 that is regarded as “living” at the time of starting the garbage collection process, and further using other indices.

Further, in the thirteenth embodiment, the mark-sweep method and the stop-copy method are used in combination. However, these methods may be replaced with a method in which both are made incremental, and furthermore, other existing technologies are used. Alternatively, the other methods described in the other embodiments according to the present invention may be replaced, and three or more methods may be used in combination.

Embodiment 14 FIG. Embodiment 1 of the present invention
No. 4 shows that the garbage collection process operates differently depending on the condition of the activation trigger under different conditions from the twelfth and thirteenth embodiments. The basic configuration is the same as that of the twelfth embodiment, and the description is omitted.

FIG. 27 is a flowchart showing the operation of the fourteenth embodiment. In the garbage collection process (GC process) S250 in the fourteenth embodiment, when the computer system has been started up, the memory acquisition unit 3 requests from the application program while the application program is running due to the lack of the remaining available area 13. It is started only when the specified amount of the object area 10 cannot be obtained, and is started periodically at a constant cycle as shown in the ninth embodiment in the steady stage of the computer system. For this reason, the garbage collection process S25 of the fourteenth embodiment
If the start time is the start-up stage of the computer system (left branch in S2501 in the drawing), first, the garbage collection process of the mark-sweep method shown as the third conventional example is performed (S251). If the necessary object area 10 can be secured (Ye in S2302)
s) The process ends, and if the necessary object area 10 cannot be secured by only the step S251 (N in S2302)
o) In a manner similar to the procedure 1612 in the seventh embodiment (FIG. 14), the valid object area 10 is moved by copying so that the necessary object area 10 can be secured, and a plurality of objects in the free list 18 are moved. Combine available memory areas into a single memory area (S23)
2). On the other hand, when the garbage collection process S250 is started in a steady state of the computer system (S2
501, a garbage collection process according to the present invention shown in the third to ninth embodiments, for example, performs a copy-type garbage collection process on a part of the already-acquired area 14 and performs a remaining process. The usable area 13 is expanded (S253).

In the fourteenth embodiment, as described above, the processing contents are changed in accordance with the operation status of the computer system at the time of the start of the garbage collection process S230. Garbage collection processing is performed so as to shorten the processing time required for the garbage collection, and the garbage collection processing can be performed in a normal stage of the computer system so that the responsiveness of the operation of the application program is good.

In the fourteenth embodiment, at the start-up stage of the computer system, first, the mark-sweep garbage collection process S25 shown in the third conventional example is performed.
1 and then the free list 1 in step S252.
8, the available memory areas are combined into a single area. However, the present procedure is applicable to any method that can shorten the entire processing time of the start-up phase of the computer system. Similarly, in the normal stage of the computer system, any method may be used as long as the response of the operation of the application program can be improved.

Embodiment 15 FIG. Embodiment 1 of the present invention
5 is obtained by synthesizing and improving the twelfth and fourteenth embodiments, in which the garbage collection process performs different operations according to the conditions of the activation trigger according to more complex conditions. The basic configuration is the first embodiment.
Since the configuration is the same as that of the second embodiment, the description is omitted.

FIG. 28 is a flowchart showing the operation of the fifteenth embodiment. In the garbage collection process (GC process) S260 in the fifteenth embodiment, the memory acquisition unit 3 could not acquire the object area 10 requested by the application program during the operation of the application program due to the shortage of the remaining available area 13. In the normal stage of the computer system,
As described in the ninth embodiment, it is started periodically at a constant cycle. For this reason, if the garbage collection process S250 of the fifteenth embodiment is in the startup stage of the computer system (lower branch in S2501 in the figure), the entire acquired area 14 is processed (S2).
601), the mark-sweep type shown as the third conventional example for the target area, or the twelfth embodiment (FIG.
The non-copy-type garbage collection process according to the procedure S231 of 5) is performed (S261), and if the necessary object area 10 can be secured (Ye in S2302)
s) The process ends, and if the necessary object area 10 cannot be secured by only the step S261 (N in S2302)
o) In a manner similar to the procedure 1612 in the seventh embodiment (FIG. 14), the valid object area 10 is moved by copying so that the necessary object area 10 can be secured, and a plurality of objects in the free list 18 are moved. Combine available memory areas into a single memory area (S23)
2). On the other hand, when the garbage collection process S260 is started at the steady stage of the computer system (S2
501 (right branch in the figure), and then determine the start timing of the garbage collection process (S2301). If the start timing is insufficient for the remaining available area 13, the memory acquisition means 3 requests from the application program while the application program is running. If the required amount of object area 10 cannot be obtained (lower branch in S2301 in the figure), a part of the already obtained area 14 is to be processed (S2602), and the procedure 261 is performed to execute the necessary object area. The process ends when 10 can be secured (Ye in S2302).
s), object area 1 required only in step S261
If 0 cannot be secured (No in S2302), step S232 is further performed. The garbage collection process S
If the start of step 260 is a normal stage of the computer system (right branch in S2501 in the figure) and the start of the garbage collection process is a periodic operation as shown in the ninth embodiment (see the figure of S2301) (Right branch) First, copy-type garbage collection processing is performed on a part of the already acquired area by, for example, the garbage collection processing described in Embodiments 3 to 9 to expand the remaining available area (S253). ), If the remaining available area 13 to be secured by the periodic operation can be obtained (Yes in S2603)
s) When the processing is completed and the remaining available area 13 is still insufficient (No in S2603), the target area is further expanded and the copy-type garbage collection process is performed again on the entire acquired area 14 to perform the remaining available area. 13 is expanded (S264).

In the fifteenth embodiment, as described above, the operating status of the computer system at the time of starting the garbage collection process S260 and the garbage collection process S2
Since the processing contents are changed in response to the start timing of the computer system 60, the processing time required for the startup can be reduced in the startup stage of the computer system, as in the fourteenth embodiment. In the stage, as in the twelfth embodiment, the activation trigger is the remaining available area 13
Memory acquisition means 3 during application program operation due to lack of
Does not obtain the object area 10 of the required amount from the application program, it operates so that the interruption time of the application program becomes as short as possible. Then, while suppressing the load of the garbage collection processing, the available memory area in the remaining available area 13 is made to be a continuous area as large as possible, and the operation is performed so that interruption of the application program hardly occurs. The responsiveness of the operation of the application program can be improved.

In the fifteenth embodiment, at the start-up stage of the computer system, first, the garbage collection process S25 of the mark-sweep system shown in the third conventional example is performed.
1 and then the free list 1 in step S252.
8, the available memory areas are combined into a single area. However, the present procedure is applicable to any method that can shorten the entire processing time of the start-up phase of the computer system. Similarly, in the normal stage of the computer system, any method may be used as long as the response of the operation of the application program can be improved. In addition, a first or second conventional example,
Alternatively, by using the garbage collection process of the reference counter method as described in the first and second embodiments, it is possible to further suppress the shortage of the remaining available area 13 during the operation of the application program. .

Further, the twelfth to fifteenth embodiments
In the above, by changing or adding the judgment condition and changing or adding the garbage collection method executed according to the condition, the reason for the trigger of the garbage collection process, the operation state of the program, the dynamic memory management mechanism 1 The garbage collection method can be easily applied to different operating characteristics according to the internal state of the system, the operating state of the system, and other system states. The operating characteristics required for the garbage collection process can be changed as appropriate to achieve optimal operating characteristics and improve the performance of the computer system.

Embodiment 16 FIG. Embodiment 1 of the present invention
Reference numeral 6 relates to the operation timing of the application program and the garbage collection process. The basic configuration is the same as that of the third embodiment, and the description is omitted.

FIG. 29 is a flowchart showing the operation of the sixteenth embodiment. The garbage collection process (GC process) S301 according to the sixteenth embodiment is started and operated periodically at a constant cycle, similarly to the ninth embodiment. In the sixteenth embodiment, when an application program explicitly instructs execution of garbage collection processing in the program (S300), the garbage collection processing is not performed as an extension of the processing of the application program, but is simply executed periodically. Garbage collection processing S30
1 is waited for (S3001), and when the garbage collection process S301 is performed and the wait is released, the process is terminated. On the other hand, when the garbage collection process S301 is started periodically, first, as a process S302 for collection and reuse of “garbage”, for example, a garbage collection process of the stop-copy method shown in the fifth conventional example, or A more advanced garbage collection process as described in the ninth embodiment is executed, and then the waiting is canceled for one or a plurality of application programs waiting for the end of the process S302 (S3011).

Next, the operation of the sixteenth embodiment will be described with reference to FIG. FIG. 30 is an explanatory diagram showing the operation of the sixteenth embodiment. In the sixteenth embodiment, similarly to the ninth embodiment, the application program and the garbage collection process (GC process) S301 are performed at regular intervals. It operates periodically at the interval T1. In the sixteenth embodiment, there are three types of application programs A, B, and C, and their processing priorities are in the order of A>B> C.
It is started at the same timing, but basically A, B,
The operation starts in the order of C, and B and C cannot operate while A is operating, and C is not operated while B is operating. Garbage collection processing S
Since the processing priority of the application program 301 is lower than that of any of the application programs A, B, and C, the operation of the application program 301 is controlled so that the application program 301 cannot operate while the application program A, B, or C is operating.

Time t1 is a trigger for starting the application programs A, B, C and the garbage collection process S301.
According to the processing priority, first, the application program A starts at time t1.
It operates during t2, and after the operation of application program A ends, application program B starts operation at time t2.
However, when the application program B explicitly instructs the execution of the garbage collection process as a part of the process of the program at the time t3 (S300), the application program B waits for the end of the garbage collection process S301 (S300).
3001), the application program C becomes executable and its execution starts. The application program C ends the processing at time t4, and then performs the garbage collection processing S30
When the garbage collection process S301 ends at the time t5, the queuing of the application program B stopped in step S3011 is released.
The application program B resumes the processing, and ends the processing at time t6.

According to the sixteenth embodiment, as described above, in a computer system in which garbage collection processing operates periodically, when an application program with a high processing priority explicitly instructs execution of garbage collection processing, Since the operation is performed so as to give priority to the operation of another application program without advancing the garbage collection processing on extension of the processing priority, the responsiveness of the operation of the application program is improved.

Embodiment 17 FIG. Embodiment 1 of the present invention
7 relates to the operation timing of the application program and the garbage collection process. The basic configuration is the same as that of the third embodiment, and the description is omitted.

FIG. 31 is a flowchart showing the operation of the seventeenth embodiment. The garbage collection process (GC process) S301 according to the seventeenth embodiment is the same as the garbage collection process according to the sixteenth embodiment, and is started and operated periodically at a constant cycle, similarly to the ninth embodiment. . In the seventeenth embodiment, when the application program tries to acquire the object area 10 in the program (S310), first, it is checked whether the required object area 10 can be secured from the remaining available area 13 (S3101). If it is possible (Yes in S3101), the object area 10 is promptly secured by using the memory acquisition means 3 (S3102), and the process ends.
On the other hand, if the garbage collection processing cannot be secured (No in S3101), the garbage collection processing is not performed as an extension of the processing of the application program. Is performed and the waiting is released, the process returns to the inspection (S3101) to determine whether the necessary object area 10 can be secured again, and the steps S3101 and S3 continue until the required object area 10 can be secured.
Repeat 3001. On the other hand, the garbage collection process S301 is the same as the operation in the sixteenth embodiment. A garbage collection process of a copy method or a more advanced garbage collection process as described in the ninth embodiment is executed, and then the process S3
The waiting is canceled for one or more application programs waiting for the end of 02 (S3011).

Next, the operation of the seventeenth embodiment will be described with reference to FIG. FIG. 32 is an explanatory view showing the operation of the seventeenth embodiment. In the seventeenth embodiment, similarly to the sixteenth embodiment, the application program and the garbage collection process (GC process) S301 are executed at regular intervals, at regular intervals. It operates periodically at T1. Embodiment 1
6, there are three types of application programs, A, B, and C, and their processing priorities are in the order of A>B> C.
The operation is started in the order of B and C, and B and C cannot operate while A is operating, and C is not operated while B is operating. Since the garbage collection process S301 has a lower processing priority than any of the application programs A, B, and C, the garbage collection process S301 is controlled so as not to operate while any of the application programs A, B, and C is operating. You.

The time t1 is a trigger for starting the application programs A, B, and C and the garbage collection processing S301.
According to the processing priority, first, the application program A starts at time t1.
It operates during t2, and after the operation of application program A ends, application program B starts operation at time t2.
However, at the time t3, the application program B obtains the object area 10 as the processing of the program at step S3.
10 and the remaining available area 13 is insufficient (S310).
From No. 1), the process waits for the end of the garbage collection process S301 (S3001), and the application program C becomes executable and its execution starts. Further, at time t4, the application program C also waits for the end of the garbage collection processing S301 due to the shortage of the remaining available area 13 (No in S3101), when the acquisition S310 of the object area 10 is performed as the processing of the program at the time t4. (S3001) Therefore, the process proceeds to the garbage collection process S301, and when the process of the garbage collection process S301 ends at the time t5, the waiting of the application programs B and C stopped in the step S3011 is released. Both the application programs B and C resume their processing. However, since the application program B has a higher processing priority, the application program B operates first, ends the processing at time t6, and then the application program C operates. The process ends at time t7 That.

In the seventeenth embodiment, as described above, in a computer system in which garbage collection processing operates periodically, the operation of the application program needs to wait for the execution of the garbage collection processing due to the shortage of the remaining available area 13. In such a case, the operation of another application program is performed with priority, without performing the garbage collection process on the extension of the processing priority, so that the responsiveness of the operation of the application program is improved, and the garbage collection process is also performed. Operate collectively, so that the processing efficiency can be improved.

Embodiment 18 FIG. Embodiment 1 of the present invention
8 relates to the operation timing of the application program and the garbage collection process. The basic configuration is the same as that of the third embodiment, and the description is omitted.

FIG. 33 is a flow chart showing the operation of the eighteenth embodiment. The garbage collection process (GC process) S321 according to the eighteenth embodiment is started and operated periodically at a constant cycle, similarly to the ninth embodiment. In the eighteenth embodiment, when the application program attempts to acquire the object area 10 in the program (S320), it is checked whether the required object area 10 can be secured from the remaining available area 13 (S3101). If the object area 10 can be secured (Yes in S3101), the object area 10 is quickly secured using the memory acquisition means 3 (S3102), and the process ends.
On the other hand, if it cannot be secured (No in S3101), the garbage collection processing is not performed as an extension of the processing of the application program, and the request amount of the object area 10 required by the own program and the other program And an additional register, such as a process ID, for distinguishing the program from the own program (S320).
1) Waiting for the release of the wait from the garbage collection process S301 which is periodically executed thereafter (S320)
2) When the queuing is released, the process returns to the inspection (S3101) for determining whether the necessary object area 10 can be secured again, and repeats the steps S3101, S3201, and S3202 until the required object area 10 can be secured. When the application program explicitly instructs the execution of the garbage collection process in the program (S30)
0), as in the sixteenth embodiment, a garbage collection process S301 that is simply performed periodically without performing a garbage collection process on the extension of the processing of the application program.
(S3001), and when the garbage collection process S301 is performed and the waiting is released, the process is terminated.

On the other hand, the garbage collection processing (GC processing) S321 is substantially the same as the garbage collection processing S200 shown in the ninth embodiment, and is roughly divided into the following three stages, preprocessing S201, and repeated unit processing S20.
2. Post-processing S203 is performed, and every time the apparatus is started periodically, first, a pre-processing S201 is performed as a preparation before entering the repetition processing S202 in the garbage collection processing, and then a repetition processing S of the garbage collection processing is performed.
202 is executed for one unit process. Thereafter, the registered contents of the GC processing waiting list 19 are checked (S3211).
Then, it is checked whether there is an application program that can secure the required object area 10 based on the current amount of the remaining available area 13 (Yes in S3212).
In step S3213, the corresponding application program is released from queuing based on the identifier of the program registered in the GC processing waiting list 17 (S3213), and the corresponding entry is deleted from the GC processing waiting list 17 (S3214).
If there is no application program that can secure the required object area 10 with the current amount of the remaining available area 13 (No in S3213), the procedures S3213 and S3214 are not performed. Then, further repetition processing S
If it is necessary to continue 202 (No in S2002),
The above steps S202 to S2002 are repeated, and when it is no longer necessary to perform the repetition process S202 (Yes in S2002), the post-process S203 is performed as the end of the garbage collection process, and thereafter 1 to Cancel the waiting for a plurality of application programs (S3011)
The process ends.

The details of steps S201, S202, and S203 are the same as those in the ninth embodiment, and will not be described. However, in the eighteenth embodiment, unlike the ninth embodiment, the processing shown in step S202 is always repeated a necessary number of times, and therefore, when the repetition is stopped halfway, inconsistency occurs. Regardless, available garbage collection options are wider than in the ninth embodiment.

Next, the operation of the eighteenth embodiment will be described with reference to FIG. FIG. 34 is an explanatory diagram showing the operation of the eighteenth embodiment. In the eighteenth embodiment, similarly to the sixteenth embodiment, the application program and the garbage collection process (GC process) S321 are executed at regular intervals. It operates periodically at T1. Embodiment 1
6, there are three types of application programs, A, B, and C, and their processing priorities are in the order of A>B> C.
The operation is started in the order of B and C, and B and C cannot operate while A is operating, and C is not operated while B is operating. Since the garbage collection process S321 has a lower processing priority than any of the application programs A, B, and C, the garbage collection process S321 is controlled such that it cannot operate while any of the application programs A, B, and C is operating. You.

Time t1 is a trigger for starting the application programs A, B, C and the garbage collection process S321.
According to the processing priority, first, the application program A starts at time t1.
It operates during t2, and after the operation of application program A ends, application program B starts operation at time t2.
However, when the application program B explicitly instructs the execution of the garbage collection process as a part of the process of the program at the time t3 (S300), the application program B waits for the end of the garbage collection process S301 (S300).
3001) As a result, the application program C becomes executable and its execution starts. When the application program C tries to acquire the object area 10 as processing of the program at the time t4, the application program C needs to be placed in the GC processing waiting list 19 due to the shortage of the remaining available area 13 (No in S3101). Register the quantity and identifier (S3
201), and then garbage collection processing S301
Then, the process enters a waiting state for waiting (S3202), and then proceeds to a garbage collection process S321.

In the garbage collection process S321,
When the procedure S202 is repeated several times, the remaining available area 13 increases until the object area 10 required by the application program C can be obtained. Is released at time t5 (S3213). as a result,
In step S3202, the queuing of the application program C which has been stopped is released, and the application program C resumes its processing, and ends the processing at time t6. Thereafter, the garbage collection process is restarted in S321, and the process that was stopped at the time t5 by the operation of the application program C is restarted. At the time t7, the garbage collection process S
When 321 ends, the queuing of the application program B that has been stopped in step 3011 is released, the application program B resumes its processing, and ends the processing at time t8.

According to the eighteenth embodiment, as described above, in a computer system in which garbage collection processing operates periodically, when the operation of an application program needs to wait for the execution of garbage collection processing, the processing priority is An application program that operates so as to give priority to the operation of another application program without advancing the garbage collection process on the extension and that needs to wait for the execution of the garbage collection process due to a shortage of the remaining available area 13. The application program that instructs the execution of the garbage collection process operates so that the former operation takes precedence, and furthermore, a plurality of application programs that need to wait for the execution of the garbage collection process due to the lack of the remaining available area 13. Now, the priority is given to the operation of application programs that require less Because, to improve the responsiveness of the operation of the application program.

In the eighteenth embodiment, step S32
13. In step S3214, the waiting is canceled only for one of the applicable application programs.
In this case, the queuing may be released for a plurality of application programs. In this case, the application programs whose queuing has been released acquire the object area 10 as much as possible in the order of the processing priority. Thus, the responsiveness of the operation of the application program is further improved.

In addition, the garbage collection processing shown in the eighteenth embodiment is combined with the ninth or tenth embodiment to limit the execution time, and as described in the third embodiment. The processing may be changed so that the processing is interrupted when the acquired remaining available area exceeds a certain threshold, and the effects of the respective embodiments can be obtained. However, if such a change is made, the process shown in step S202 may be repeated only less than the required number of times.
It is necessary to adopt a garbage collection method as described in the third, ninth or tenth embodiment so that inconsistency does not occur even when the repetition of step S202 is stopped halfway.

[0251]

As described above, according to the first aspect of the present invention, in the dynamic memory management mechanism having the garbage collection means using both the reference counter method and another method, the operation of changing the value of the pointer is performed. Is predictable and its implementation can be simplified.

Further, according to the second aspect of the present invention, in addition to the effect of the first aspect, there is an effect that the efficiency of the garbage collection process can be enhanced by the dynamic memory management mechanism according to the first aspect.

According to a third aspect of the present invention, in the dynamic memory management mechanism having garbage collection means,
There is an effect that the memory leak phenomenon and the fragmentation phenomenon do not occur and the memory use efficiency can be improved.

According to claim 4 of the present invention, in addition to the effect of claim 3, there is an effect that the processing time of the entire garbage collection process can be shortened.

According to the fifth aspect of the present invention, in addition to the effect of the third aspect, there is an effect that the processing time of the entire garbage collection process can be reduced.

According to claim 6 of the present invention, in addition to the effect of claim 3, there is an effect that the efficiency of the garbage collection process can be improved.

According to the seventh aspect of the present invention, in addition to the effect of the third aspect, the efficiency of the garbage collection process can be improved, and the operation of the garbage collection process can be simplified.

According to the eighth aspect of the present invention, in addition to the effect of the third aspect, there is an effect that the efficiency of the garbage collection process can be improved.

According to the ninth aspect of the present invention, in a dynamic memory management mechanism having a garbage collection means of a type involving copying of an object area, the processing can be simplified, and the speed of the garbage collection processing can be further reduced. There is an effect that is increased.

According to the tenth aspect of the present invention, in the dynamic memory management mechanism having the garbage collection means that operates periodically, the constant response of the computer system is improved without hindering the periodic operation of the application program. There is an effect that can be.

According to claim 11 of the present invention, claim 1
In addition to the effect of 0, there is an effect of stabilizing the operation of the computer system.

According to claim 12 of the present invention, claim 1
In addition to the effect of 0, there is an effect that the memory use efficiency is improved.

According to claim 13 of the present invention, claim 1
In addition to the effect of 2, there is an effect that the operation of the application program and the operation of the entire computer system become more stable.

According to the fourteenth aspect of the present invention, in the dynamic memory management mechanism having the garbage collection means, there is an effect that the performance of the computer system is improved.

According to the fifteenth aspect of the present invention, in the dynamic memory management mechanism having the garbage collection means, there is an effect that the responsiveness of the operation of the application program is improved.

According to the sixteenth aspect of the present invention, in the dynamic memory management mechanism having the garbage collection means, there is an effect that the operation of the computer system is stabilized.

According to the seventeenth aspect of the present invention, in the dynamic memory management mechanism having the garbage collection means, the startup processing time is shortened at the startup stage of the computer system, and the startup time of the application program is reduced at the steady stage of the computer system. This has the effect of improving the responsiveness of the operation.

According to the eighteenth aspect of the present invention, in the dynamic memory management mechanism having the garbage collection means which operates periodically, there is an effect that the responsiveness of the operation of the application program is improved.

According to the nineteenth aspect of the present invention, in the dynamic memory management mechanism having garbage collection means that operates periodically, there is an effect that the responsiveness of the operation of the application program is improved.

According to claim 20 of the present invention, claim 1
In addition to the effect of No. 8, there is an effect that the efficiency of the garbage collection process can be enhanced.

According to the twenty-first aspect of the present invention, in the dynamic memory management mechanism having the garbage collection means which operates periodically, there is an effect that the responsiveness of the operation of the application program is improved.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration of a dynamic memory management mechanism according to Embodiment 1 of the present invention.

FIG. 2 is a flowchart showing an operation of the dynamic memory management mechanism according to the first embodiment of the present invention.

FIG. 3 is an explanatory diagram showing a state before the operation is performed in the first embodiment of the present invention.

FIG. 4 is an explanatory diagram showing a state after the operation is performed in the first embodiment of the present invention.

FIG. 5 is a flowchart showing an operation of a dynamic memory management mechanism according to Embodiment 2 of the present invention.

FIG. 6 is an explanatory diagram showing a state after execution of an operation according to the second embodiment of the present invention.

FIG. 7 is a block diagram showing a configuration of a dynamic memory management mechanism according to Embodiment 3 of the present invention.

FIG. 8 is a flowchart showing an operation of a dynamic memory management mechanism according to Embodiment 3 of the present invention.

FIG. 9 is an explanatory diagram showing an operation in the third embodiment of the present invention.

FIG. 10 is a flowchart showing the operation of the fourth embodiment of the present invention.

FIG. 11 is an explanatory diagram showing an operation in the fifth embodiment of the present invention.

FIG. 12 is an explanatory diagram showing an operation according to the sixth embodiment of the present invention.

FIG. 13 is an overall flowchart showing the operation of the seventh embodiment of the present invention.

FIG. 14 is a flowchart showing a partial compact process according to the seventh embodiment of the present invention.

FIG. 15 is an explanatory diagram showing an operation according to the seventh embodiment of the present invention.

FIG. 16 is a configuration diagram showing an eighth embodiment of the present invention.

FIG. 17 is a flowchart showing the operation of the ninth embodiment of the present invention.

FIG. 18 is an explanatory diagram showing an operation in Embodiment 9 of the present invention.

FIG. 19 is a flowchart showing the operation of the tenth embodiment of the present invention.

FIG. 20 is an explanatory diagram showing an operation in the tenth embodiment of the present invention.

FIG. 21 is a flowchart showing an operation of the eleventh embodiment of the present invention.

FIG. 22 is an explanatory diagram showing an operation in Embodiment 11 of the present invention.

FIG. 23 is a block diagram showing a configuration of a dynamic memory management mechanism according to Embodiment 12 of the present invention.

FIG. 24 is an overall flowchart showing the operation of Embodiment 12 of the present invention.

FIG. 25 is a flowchart illustrating non-copy garbage collection processing according to a twelfth embodiment of the present invention.

FIG. 26 is a flowchart showing the operation of Embodiment 13 of the present invention.

FIG. 27 is a flowchart showing an operation according to the fourteenth embodiment of the present invention.

FIG. 28 is a flowchart showing the operation of Embodiment 15 of the present invention.

FIG. 29 is a flowchart showing the operation of the sixteenth embodiment of the present invention.

FIG. 30 is an explanatory diagram showing an operation in Embodiment 16 of the present invention.

FIG. 31 is a flowchart showing an operation of the seventeenth embodiment of the present invention.

FIG. 32 is an explanatory view showing operation in Embodiment 17 of the present invention.

FIG. 33 is a flowchart showing an operation according to the eighteenth embodiment of the present invention.

FIG. 34 is an explanatory diagram showing an operation according to the eighteenth embodiment of the present invention.

FIG. 35 is an explanatory diagram showing a distinction between “live” storage areas and “garbage” in the garbage collection process.

FIG. 36 is a block diagram showing a configuration of a dynamic memory management mechanism of a first conventional example.

FIG. 37 is a flowchart showing an operation of acquiring an object area in the first conventional example.

FIG. 38 is a flowchart showing an operation of changing the value of a pointer in the first conventional example.

FIG. 39 is an explanatory diagram showing a state before performing a first operation in a first conventional example.

FIG. 40 is an explanatory diagram showing an intermediate stage 1 of performing the first operation in the first conventional example.

FIG. 41 is an explanatory view showing an intermediate stage 2 of performing the first operation in the first conventional example.

FIG. 42 is an explanatory view showing a state after the first operation in the first conventional example.

FIG. 43 is an explanatory diagram showing a state before performing a second operation in the first conventional example.

FIG. 44 is an explanatory diagram showing a state after performing the second operation in the first conventional example.

FIG. 45 is a flowchart showing the operation of the second conventional example.

FIG. 46 is a block diagram showing a configuration of a dynamic memory management mechanism of a third conventional example.

FIG. 47 is a flowchart showing the operation of the third conventional example.

FIG. 48 is an explanatory diagram showing an operation in the third conventional example.

FIG. 49 is a block diagram showing a configuration of a dynamic memory management mechanism of a fourth conventional example.

FIG. 50 is a flowchart showing the operation of the fourth conventional example.

FIG. 51 is an explanatory diagram showing an operation in a fourth conventional example.

FIG. 52 is a block diagram showing a configuration of a fifth conventional dynamic memory management mechanism.

FIG. 53 is a flowchart showing the operation of the fifth conventional example.

FIG. 54 is an explanatory diagram showing an operation in the fifth conventional example.

FIG. 55 is a block diagram showing a configuration of a dynamic memory management mechanism of a sixth conventional example.

FIG. 56 is a flowchart showing the operation of the seventh conventional example.

FIG. 57 is a block diagram showing the configuration of an eighth conventional dynamic memory management mechanism.

FIG. 58 is a flowchart showing a first operation in the eighth conventional example.

FIG. 59 is an explanatory diagram showing a first operation in the eighth conventional example.

FIG. 60 is a flowchart showing a second operation in the eighth conventional example.

FIG. 61 is an explanatory diagram showing a second operation in the eighth conventional example.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 Dynamic memory management mechanism, 2 heap area, 3 memory acquisition means, 4 memory release means, 5 garbage collection means, 10 object area, 11 reference counter, 12 pointer, 13 remaining available area, 14 already acquired area, 15 TO area, 16 FROM area,
17 reference table, 18 free list, 19 garbage collection (GC) processing waiting list, 20 mark, 21 garbage list, 22 indirect pointer, 23 OL
D area.

Claims (22)

[Claims] 1. a heap area; a memory obtaining means for obtaining a part of the heap area from the heap area as an object area; a memory releasing means for returning the obtained object area to the heap area for re-use; Garbage collection means for searching for an object area acquired by the acquisition means but no longer used by the program, and releasing the object area to the heap area by using the memory releasing means. And the value of each reference counter increases or decreases so as to indicate the number of pointers that refer to the corresponding object area. The garbage collection means responds when the value of the reference counter becomes 0. Reference counter garbage collector that frees object area When the reference processing is performed and the corresponding first object area is released when the value of the reference counter becomes 0 and the garbage collection processing by another method is operated in combination, the first object area Open only the second object referenced by one or more pointers in the first object area.
A dynamic memory management mechanism which does not perform a process of updating the value of a reference counter and a process of releasing an object area which may occur in association with the object area. 2. The method according to claim 1, wherein when the value of the reference counter becomes 0 and the first object area is released, a value of one or a plurality of pointers in the area of the first object is set. 2. The dynamic memory management mechanism according to claim 1, wherein the value is set to an invalid value. 3. A heap area, memory acquisition means for acquiring a part of the heap area from the heap area as an object area, memory release means for returning the acquired object area to the heap area for reuse, and the memory Garbage collection means for searching for an object area acquired by the acquisition means but no longer used by the program, and releasing the object area to the heap area by using the memory release means, wherein the memory acquisition means comprises: The object area is sequentially acquired from one end of the remaining available area, and the garbage collection means first sets the remaining available area as a TO area, and the same or less acquired area adjacent to the TO area as a FROM area. And moving individual object areas by copying Then, a new remaining available area, which is a combination of the area of the TO area where the object area remains usable without moving and the empty FROM area, is set as a new TO area. A partial garbage collection process is performed again as a new FROM area with an area of the same amount as the new remaining available area among the already acquired areas that have not been subjected to the garbage collection processing until the garbage collection processing reaches the entire already acquired area. A dynamic memory management mechanism characterized by repeating the partial garbage collection process similarly thereafter. 4. When the partial garbage collection process is repeated, if the size of the newly generated remaining available area exceeds a certain threshold value during the repetition of the partial garbage collection process, the repetition is stopped there. 4. The dynamic memory management mechanism according to claim 3, wherein: 5. The garbage collection means, before repeating the partial garbage collection processing, first creates a base pointer list of an object area referenced from an existing pointer outside the heap area, and then repeats the partial garbage collection processing Then, processing is performed using the pointer held by the base pointer list instead of the pointer existing outside the heap area, and when the object area referred to by the pointer is copied to the TO area, the pointer is replaced with the base pointer. The dynamic memory management mechanism according to claim 3, wherein the dynamic memory management mechanism is deleted from the list. 6. The garbage collection means is configured to obtain an object area from the remaining available area so that the remaining available area, which is a TO area, always moves in one direction in the heap area when the garbage collection process is repeated. The relative position between the FROM area and the TO area in the heap area is fixed.
Dynamic memory management mechanism as described. 7. The garbage collection means may be configured to obtain an object area from the remaining available area and a heap area so that the remaining available area as a TO area reciprocates in the heap area when the garbage collection process is repeated. 4. The dynamic memory management mechanism according to claim 3, wherein a relative position between the FROM area and the TO area is changed. 8. The garbage collection means according to claim 1, wherein
When the remaining available area, which is an area, is small, the FORM area set adjacent to the TO area from the already acquired area is set to the TO area.
First, an effective object area in the FROM area is searched for without moving the object area, and then the effective object area in the FORM area is searched for an area obtained by combining the FROM area and the TO area. After filling at one end to increase the remaining available area,
The dynamic memory management mechanism according to claim 3, wherein the partial garbage collection process is performed. 9. A heap area, a memory obtaining means for obtaining a part of the heap area from the heap area as an object area, a memory releasing means for returning the obtained object area to the heap area for re-use, and the memory Garbage collection means for searching for an object area acquired by the acquisition means but no longer used by the program, and releasing the object area to the heap area by using the memory release means, wherein the pointer for referring to each object area is directly , A reference to an entry of a reference table, and reference of an object area by the pointer is always performed via an entry of the reference table. 10. A heap area, memory acquisition means for acquiring a part of the heap area as an object area, memory release means for returning the acquired object area to the heap area for reuse, and the memory Garbage collection means for searching for an object area acquired by the acquisition means but no longer being used by the program, and releasing the object area to the heap area using the memory release means. A dynamic memory management mechanism operable to perform garbage collection processing only in the following. 11. The garbage collection means refers to a flag that changes true / false periodically at a constant ratio,
11. The dynamic memory management mechanism according to claim 10, wherein the dynamic memory management mechanism operates to perform a garbage collection process only while the flag is true. 12. The garbage collection means has a counter for indicating whether or not garbage collection processing can be performed, and a counter increasing means for periodically increasing the counter with an appropriate value, according to the progress of the garbage collection processing. 11. The dynamic memory management mechanism according to claim 10, wherein the garbage collection process is performed only while the value of the counter is positive while subtracting the value of the counter. 13. The garbage collection means continues garbage collection processing until the amount of the remaining available area in the heap area exceeds a certain threshold value, even if the value of the counter is negative. Claim 12
Dynamic memory management mechanism as described. 14. A heap area, memory acquisition means for acquiring a part of the heap area from the heap area as an object area, memory release means for returning the acquired object area to the heap area for reuse, and the memory Garbage collection means for searching for an object area acquired by the acquisition means but no longer used by the program, and releasing the object area to the heap area using the memory release means, wherein the garbage collection means performs garbage collection processing A dynamic memory management mechanism characterized by using a different garbage collection method as appropriate according to the system state, such as the trigger, the operating status of the program, the internal status of the dynamic memory management mechanism, or the operating status of the system. . 15. The garbage collection means is performed temporarily because the memory acquisition means cannot acquire the amount of object area requested from the application program during the operation of the application program due to a shortage of the remaining available area in the heap area. 15. The dynamic memory management mechanism according to claim 14, wherein different garbage collection methods are used depending on whether the processing is performed at a preset timing. 16. The garbage collection means according to the number of object areas acquired by the memory acquisition means after the most recently performed garbage collection processing and not yet subjected to garbage collection processing, 15. The dynamic memory management mechanism according to claim 14, wherein different garbage collection methods are selectively used. 17. The garbage collection means uses a different garbage collection method depending on whether the computer system is operating as a system startup stage or when the computer system is operating as a steady stage of the system. The dynamic memory management mechanism according to claim 14. 18. A heap area, a memory obtaining means for obtaining a part of the heap area from the heap area as an object area, a memory releasing means for returning the obtained object area to the heap area for reuse, and the memory Garbage collection means for searching for an object area acquired by the acquisition means but no longer used by the program, and releasing the object area to the heap area by using the memory release means, wherein garbage collection processing is required by the operation of the application program. In this case, a dynamic memory management mechanism that stops the operation of the application program until the garbage collection process performed at a separately determined timing is completed, instead of performing the garbage collection process immediately. 19. When an garbage collection instruction is explicitly issued from an application program, the garbage collection process is not performed immediately, but is performed until the garbage collection process performed at a separately determined timing is completed. 19. The dynamic memory management mechanism according to claim 18, wherein the operation of the application program is stopped. 20. When an application program attempts to acquire an object area using the memory acquisition means,
Since the object area required by the application program cannot be obtained from the remaining available area in the heap area, when garbage collection processing becomes necessary, instead of performing garbage collection processing immediately, at a separately determined timing 19. The dynamic memory management mechanism according to claim 18, wherein the operation of the application program is stopped until the garbage collection process to be performed ends. 21. When a plurality of application programs are waiting for the end of the garbage collection processing, the remaining available area in the heap area increased by the garbage collection processing satisfies each request of each program. 19. The dynamic memory management mechanism according to claim 18, wherein in each case, the suspension of each program is released when the processing can be continued. 22. An information recording medium in which a computer system program for realizing the dynamic memory management mechanism according to claim 1 is recorded.