JP2003050740A - Device and method of garbage collection - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a device for performing effective garbage collection by suppressing memory use quantity, when the number of referred memory cells instantaneously takes a large peak value by an operation of an application program(AP). SOLUTION: Counters as small bit strings so that the peak value of the number of referred memory cells cannot be expressed are provided in the respective memory cells, a garbage collection device 100 increases/decreases a counter within a range equal to or less than the maximum value to be expressed by the bit strings by a counter changing part 110, in the case of changes of pointers to the memory cell by the AP; and when the counter show zero, releases the memory cell by a cell releasing part 130, in addition, checks the number of the respective referred memory cells by tracing a pointer chain from a route pointer by a recounting part 140 in the case of shortage of memory, etc., releases the memory cell the result of which is zero and sets the number of checking results in counters of memory cells except zero by a counter resetting part 142.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a garbage collection of a memory used by an application program, and more particularly to a garbage collection technique using a reference counting method.

[0002]

2. Description of the Related Art A conventional programming language is a method in which the creator of an application program is not aware of securing or freeing a memory area and leaves the memory area that is no longer needed after the application program uses it to the execution environment side. There are things that take. For example, the Java language. Java is Sun Microsystem in the United States.
is a trademark of ems.

An application program written using such a language is run on an execution environment having a garbage collection mechanism for automatically releasing an unnecessary memory area. The garbage collection mechanism detects that a dynamically secured memory cell (hereinafter simply referred to as “cell”) is not referenced from anywhere when the application program is executed, and releases the cell. Make it reusable. To release the once secured cell and make it reusable,
Also referred to as collecting cells.

Here, a cell is a unit obtained by subdividing a heap area that can be dynamically used by an application program at the time of execution. Each cell is, for example, a group of variable-length areas corresponding to so-called object instances in an object-oriented programming language, and the content of each cell is a portion that is a set of a set of data and a data type, and the cell is effective. And a portion which is information for management including a valid cell flag indicating whether or not.

The data type indicates whether the corresponding data is, for example, an integer, a logical value, a pointer, or the like. Hereinafter, the pointer type data is also simply referred to as a "pointer". Further, the valid cell flag is a flag which takes a value indicating valid from the time when the cell is secured and is set to a value indicating invalid by the garbage collection mechanism when the cell is released.

A reference to a cell is made by holding a pointer to that cell. For example, when referring to cell B from cell A, cell A contains the pointer of cell B as its content. All cells referenced by the application program at a given time can be traced from one or more root pointers, either directly or via pointers in one or more cells. Here, the root pointer is defined for each unit, for example, with the whole application program or a part thereof as a unit, and depending on the execution environment of the application program,
The memory address of the cell initially secured for each unit is stored in the root pointer.

Therefore, the garbage collection mechanism treats a cell that cannot be traced from the root pointer at a certain time point as an unnecessary cell to be collected. Hereinafter, a conventional garbage collection method will be described. <0-
1. Mark-and-sweep method> The mark-and-sweep method is disclosed in Japanese Patent Laid-Open Publication No. Hei 11-232162.
In this method, after all the cells that can be traced from the root pointer are marked, the cells are scanned and the unmarked cells are collected.

FIG. 27 is a diagram for explaining the conventional mark-and-sweep method. In the figure, cells M3 and M5 are no longer needed after the cells M1 to M7 are generated by the application program. It should be noted that in the figure, a reference relationship is represented by an arrow line directed to the cell to be referred to, starting from the location of a pointer that refers to the cell.

When the garbage collection mechanism starts garbage collection, it first marks all the cells that can be traced from the root pointer RP either directly or via pointers within cells. For example, a bit area indicating the presence or absence of a mark is provided in the management information part in a cell, and a value indicating no mark is set as an initial value. When adding a mark, the bit area indicates a value indicating the presence of a mark. Change to.

As a result, the cells M1, M2, M4 and M6 are
And M7 will be marked. After that, the garbage collection mechanism scans and releases the unmarked cells. It should be noted that at the time of scanning the cells without marks, the garbage collection mechanism also performs the process of deleting the marks from the marked cells for the next garbage collection.

As a result, the unmarked cells M3 and M5 are detected, and the cells M3 and M5 are released. Since the garbage collection by the mark-and-sweep method scans all cells, if it is frequently executed, the execution performance of the application program is significantly reduced. Therefore, the garbage collection mechanism normally executes the garbage collection by the mark-and-sweep method after a certain period of time or little by little in parallel with the application program. Therefore, inevitably, the collection of the unnecessary cells will be delayed.

<0-2. Reference Count Method> In the reference count method, a count value (hereinafter, referred to as a “reference counter”) indicating from where the cell is referenced is stored for each cell in a management information part in the cell. , The reference counter is incremented or decremented each time the reference relationship changes due to a change in the pointer pointing to a cell, and the cell is collected when the reference counter reaches zero.

Specifically, when the pointer in a cell has already pointed to one of the cells and the value of the pointer is changed to another value during the execution process of the application program, the garbage collection mechanism causes , The reference counter in the cell pointed to by the original pointer value is set to 1 unless the original pointer value is NULL.
Decrement and increment the reference counter in the cell pointed to by the new pointer value by one unless the new pointer value is NULL.

Thus, the garbage collection mechanism is
A cell whose reference counter has become 0 is regarded as a cell that can no longer be traced from the root pointer, that is, an unnecessary cell, and is released. Note that the pointer contained in the cell when the cell is released is recursively changed to NULL, and the above-mentioned original pointer value is N.
Unless it is ULL, a process of decrementing the reference counter in the cell pointed by the original pointer value by 1 is executed.

FIG. 28 is a diagram for explaining a conventional reference counting method. The figure shows that the states transit in the order of state 901, state 902, and state 903. In the figure, the location where the pointer that refers to a cell is used as the starting point, and the arrow line that points to that cell indicates the reference relationship, and the numerical value in each cell refers to that cell. The reference counter, which is the number

In the state 901, in the figure, the cells M1 to M7 are used by the application program. Since the cell M5 is referenced only by the cell M4, the reference counter of the cell M5 is 1. is there. The state 901 transits to the state 902 when the application program executes a so-called assignment statement or the like to change the pointer held by the cell M4 from the value indicating the cell M5 to the value indicating the cell M6. When the pointer is changed, the reference counter of the cell M5 is decremented by 1 and becomes 0 by the garbage collection mechanism.
The reference counter of the cell M6 is incremented by 1 and becomes 2.

Subsequently, the garbage collection mechanism releases the cell M5 whose reference counter has become 0, decrements the reference counter of the cell M3 pointed to by the pointer held by the cell M5 to 0, and sets the reference counter to 0. The cell M3 which has become 0 is released. State 903 represents this result. Since the reference counter must be capable of expressing the maximum number of cells that can be referenced, an area of about 1 word is generally used for the reference counter.

The garbage collection by the reference counting method basically has an advantage that unnecessary cells can be immediately recovered, but each cell requires an area of about 1 word for a reference counter. It also has the drawback of requiring a large amount of memory space for garbage collection overall. In the reference counting method, when the chain of pointers to cells is looped, the reference counter does not become 0 even though the cell cannot be traced from the root pointer, so that unnecessary There is a problem that the cell cannot be released. In order to solve this problem, when the reference count method is used, the mark and sweep method may be used together.

<0-3. Reference Counting Method with Limiting Counter> Next, a method (hereinafter, referred to as “counter limiting reference counting method”) in which the memory area for the reference counter is reduced to compensate for the above-mentioned drawbacks of the reference counting method will be described. This method is disclosed in Japanese Patent Laid-Open No. 5-324456.

In the counter-limited reference counting method, the reference counter for each cell has only 3 bits which can represent 0 to 7, and basically the same processing procedure as the above reference counting method is executed. However, when the reference counter overflows, that is, when the number of referenced cells exceeds 7, the reference counter bits are deleted when the overflow occurs and the cells are copied to a memory area that is not subject to garbage collection. At the same time, the original cell is released.
It should be noted that the garbage collection mechanism does not operate the reference counter or collect the cells in the cells in the memory area that is not the target of the garbage collection.

Garbage collection by the counter limit reference counting method suppresses the number of bits for the reference counter, but if the number of cells overflowing the reference counter increases, the number of cells that cannot be collected increases. Therefore, the application program is newly added. There is a problem that a situation where a cell cannot be secured may occur.

[0022]

As described above, when only the mark-and-sweep method is used for garbage collection, there arises a problem that the collection of unnecessary cells is slow. The reference counting method that solves this problem has a drawback in that the amount of memory required for the reference counter is large.

The counter-limited reference counting method, which eliminates the drawbacks of the reference counting method to some extent, has a small number of cells to be referred to for most of the cells used, with the exception of a small number of cells, to one word. Is effective when the referenced number can be represented by a relatively small number of bits.

However, in the counter-limited reference counting method, when the reference number of most cells becomes very large even if it is instantaneous, the reference number is represented by a relatively small number of bits. This is not very effective, as it will overflow and render most cells irretrievable. An example of such a case will be given below.

FIG. 29 is a graph showing the change over time in the number of references to a typical cell in Java. As shown in the figure, in a general application program created by the Java language, a class that defines an object is usually inherited from other classes over multiple hierarchies. During the initialization phase of, the number of references to the source cell increased rapidly, after the initialization the cell with the reference pointer to the source cell disappeared, and at a later time the The referenced number of the original cell fluctuates in the small value range.

When executing such an application program, the counter-limited reference counting method is not effective because a small number of bits cannot be used as a reference counter.
Therefore, the present invention has been made in view of such problems, and a garbage collection method that is effective even when the number of cells referred to by the operation of an application program has a large peak value instantaneously, and the same It is an object to provide a garbage collection device using the method.

[0027]

In order to achieve the above object, the garbage collection device according to the present invention is provided in each memory cell when the reference state to the memory cell is changed by the execution of the application program. Reference count means for performing garbage collection by the reference count method using the referenced counter and execution of the application program 1 independently
For the above memory cells, independent count means for checking the number of actually referenced memory cells, and setting means for setting the number of the check result by the independent count means in the referenced counter of the corresponding memory cell. And is provided.

Further, in the garbage collection method according to the present invention, when the reference state to the memory cell is changed by the execution of the application program, the referenced counter provided in each memory cell is used to perform the garbage collection by the reference count method. A reference count step of performing collection, an independent count step of checking the number of actually referenced memory cells in one or more memory cells independently of the execution of an application program, and a result of the check by the independent count step. And a setting step of setting a certain number to the referenced counter of the corresponding memory cell.

Here, "independently of executing the application program" in the description of the independent counting means and the independent counting step is executed, for example, by a so-called assignment code or the like for designating pointer change in the application program. It means that the investigation by the independent counting means or the like is not an operation included in the conventional reference counting method.

In the case where the number of referenced cells in the cell fluctuates greatly over time, such as a momentarily large peak value, the referenced counter should be configured with a small number of bits such that the peak value cannot be represented. Then, the referenced counter overflows and becomes invalid, but with the above configuration, the number of actually referenced cells is checked and set again in the referenced counter, so the referenced counter is corrected to the correct value. Therefore, after that, when the pointer is changed by the garbage collection of the reference count method and the cell is no longer referenced from anywhere, the cell is immediately released.

Further, the control program according to the present invention is a control program for causing a computer to perform a garbage collection process, and in the garbage collection process, a reference state to a memory cell is changed by executing an application program. Sometimes, the reference count step of performing the garbage collection by the reference count method using the referenced counter provided in each memory cell, and the execution of the application program, independently of the execution of the application program, the memory cell is actually The present invention is characterized by including an independent counting step of investigating the referenced number and a setting step of setting the number, which is the investigative result of the independent counting step, in the referenced counter of the corresponding memory cell.

By installing this control program in a computer and executing it, the above-mentioned garbage collection method can be realized.

[0033]

BEST MODE FOR CARRYING OUT THE INVENTION A garbage collection apparatus according to an embodiment of the present invention will be described below. <1. Embodiment 1><1-1.Configuration> FIG. 1 is a configuration diagram of a garbage collection apparatus 100 according to the first embodiment of the present invention.

The garbage collection device 100 is a CP
As a part of an execution environment of an application program which is realized by the control program stored in the memory being executed by the CPU in a computer provided with U, a memory and the like, operates on the operating system, and is created in the Java language or the like. It is a software-like device that can be positioned.

In the figure, the garbage collection device 100 is used when the application program is executed.
Also shown is a control mechanism 200 for transmitting instructions to a memory and a memory 300 including areas allocated as cells. The control mechanism 200 is a part of the execution environment of the application program, performs execution control such as interpretation and execution of the application program, and changes the pointer by the application program.
In addition, it is a mechanism that requests the garbage collection device 100 to execute a count-and-sweep process, which will be described later, by detecting a memory shortage and the like.

The control mechanism 200 includes a cell securing section 20.
1, a pointer setting unit 202 and a count and sweep instruction unit 210. Here, the cell securing unit 201
Corresponding to the generation of the object at the time of execution of the application program, that is, when interpreting the code for generating the object in the application program,
It has a function of securing an area in the memory 300 as a cell for storing the data of the object.

The cell holds a reference counter indicating the number of times the cell is referenced, that is, the number of pointers indicating the cell. This reference counter includes a reference counter A that is normally used in the reference counting method and should be changed according to the change of the pointer by the application program, and the number of cells referred to in the count and sweep processing described later. There are two types, a unique reference counter B used to do this. The cell data structure will be described later in detail.

The pointer setting unit 202 responds to the change of the pointer at the time of execution of the application program, that is, when interpreting the code of assignment to the object pointer in the application program, the change of the pointer is made to the garbage collection device 100. It has the function of communicating with other people. The count-and-sweep instruction unit 210 detects that the memory is insufficient, that is, the memory 30.
It has a function of requesting the garbage collection device 100 to execute the count-and-sweep process when it is detected that the memory area to which a new cell can be allocated decreases in 0.

The garbage collection device 100 has a function of performing so-called garbage collection by a modified version of the reference counting system, in which a cell secured during execution of an application program is released when the cell is no longer referenced. However, as the functional components, the counter changing unit 110, the counter zero determining unit 120, the cell releasing unit 130, the recounting unit 140,
A zero count result zero determination unit 141 and a counter reset unit 142 are provided.

Here, the counter changing unit 110 executes the pointer change handling process when it receives the pointer change notification from the pointer setting unit 202 in the control mechanism 200. The counter maximum value judging unit 111, It has a counter increment unit 112 and a counter decrement unit 113. The counter maximum value determination unit 111 determines whether or not the reference counter of the cell has reached the maximum value, the counter increment unit 112 increments the reference counter of the cell by 1, and the counter decrement unit 113. Decrements the cell reference counter by one.

The counter zero judging unit 120 judges whether or not the reference counter A of the cell decremented by the counter decrementing unit 113 is 0, and if it is 0, a function of instructing the cell releasing unit 130 to release the cell. Have. The cell releasing unit 130 releases a cell in response to an instruction from the counter zero determining unit 120 or the recount result zero determining unit 141.

The re-counting unit 140 starts the execution of the count-and-sweep process when it receives the count-and-sweep process execution request from the count-and-sweep instruction unit 210, and determines the number of cells referenced by the reference counter of the cell. It has a function of counting using B.
The zero count result zero determination unit 141
For cells whose reference counter B is 0 among all cells as a result of counting by 0, the cell releasing unit 130 is instructed to release the cell, and for cells whose reference counter B is not 0, the counter resetting unit 1
42 has a function of transmitting an instruction to reset the reference counter in the cell.

The counter resetting unit 142 has a function of copying the value of the reference counter B of the cell to which the reset instruction is transmitted to the reference counter A. <1-2. Data> Below, garbage collection device 10
A cell which is a processing target of 0 and is a data unit used for storing data of an object in an application program will be described.

FIG. 2 is a diagram showing the data structure of a cell. It should be noted that one line in the figure corresponds to a word unit that is the basic word length of the computer. Here, it is assumed that one word has 32 bits. The cell 1100 is composed of a plurality of words and includes a 1-word header portion and a variable-length data area 1106.

Here, the header portion includes a valid cell flag area 1101, a cell length area 1102, a reference counter A area 1103, and a reference counter B area 1104.
And a work flag area 1105. The valid cell flag area 1101 is a 1-bit area for storing a valid cell flag indicating whether the cell is valid or invalid. The valid cell flag takes a value of 1 if the cell is valid and a value of 0 if the cell is invalid. The cell area in which the valid cell flag is 0 becomes an area in which a new cell can be allocated by the cell reserving section 201 in response to the generation of an object in the application program, and when the cell reserving section 201 newly reserves a cell. The valid cell flag is set to 1.

Note that the cell release is realized by changing the valid cell flag from 1 to 0.
The memory area to which the cell including the valid cell flag is assigned becomes a reusable area that can be used to newly secure the cell. The cell length area 1102 is
It is a 21-bit area that stores a value indicating the cell length of the header portion and the data area. The cell length stored in this area is represented by the number of words, for example.

The reference counter A area 1103 and the reference counter B area 1104 are 4-bit areas for storing the reference counter A and the reference counter B, respectively. Both reference counters can represent numbers from 0 to 15, with a maximum value of 1
5 is used to indicate that the reference counter has overflowed because the number of times the cell is referenced is once more than 15. The number of 15 with respect to the reference counter is also referred to as a MAX value below.

The work flag area 1105 is a 2-bit area for storing a work flag used to indicate the state regarding the cell in three stages in the count and sweep process. The state related to the cell is the state in which it is not detected that it is referred to by the pointer (hereinafter, "white").
Is also expressed. ) And the state in which the cell is first referenced by a pointer (hereinafter referred to as “gray”).
Is also expressed. ) And a state in which the operation of the reference counter for the cell indicated by the pointer held by the cell has already been executed (hereinafter also referred to as “black”). If the value of the work flag is 0, the cell is white, if the value is 1, the cell is gray, and if the value is 2, the cell is black.

In the count-and-sweep process described later, a so-called three-color algorithm is used,
Each cell will change in the order of white, gray, and black.
The data area 1106 is an area for storing object data, and in this area, one or a plurality of data to which data type information such as integer type, character type, pointer type, etc. is added is stored.

FIG. 3 is a diagram showing a state in which cells are assigned to a partial area of the memory 300. In the figure, data of types other than the pointer type are expressed as "variables". For example, in the valid cell 1201, the valid cell flag is 1, the cell length is 4 words, the reference counter A is 2, the reference counter B is 0, the work flag is 0, and a pointer and the like are included. I'm out.

The free area 1211 in which the valid cell flag is 0 is an area for 3 words and can be newly secured as a cell. In the area where the plurality of cells are stored, when sequentially searching for cells, the cell length of the cell is referred to from the first cell to skip the cell size to reach the next cell. be able to.

FIG. 4 is a diagram exemplifying the contents of cells and relationships between cells at a certain point of time. In the figure, the location of the pointer is indicated by the starting point of the arrow line, and the cell pointed by the pointer is indicated by the tip of the arrow. For example, cell 11
Indicates that it is pointed to by the root pointer 10 and includes a pointer pointing to the cell 12 and a pointer pointing to the cell 15. Further, the cell 14 is shown as not being pointed to by anywhere nor being referenced from anywhere.

<1-3. Operation> Hereinafter, an operation of the garbage collection device 100 having the above-mentioned configuration and performing the garbage collection on the above-mentioned cell and the control mechanism 200 related to this, which controls the interpretation and execution of the application program will be described. . <1-3-1. Cell generation> Control mechanism 2 for sequentially interpreting application program code and controlling execution
00 causes the cell securing unit 201 to perform cell generation processing when the code for object generation is to be interpreted.

FIG. 5 is a flowchart showing a cell generation process performed by the cell securing unit 201. Cell securing unit 201
Secures a cell having a size including the amount of object data to be stored in the cell and one word of the header portion, and sets the valid cell flag of the cell to 1 (step S4
11) and set the cell length based on the size (step S412). In reserving this cell, the cell reserving unit 201 searches for a free area in the memory 300 in which the valid cell flag is 0, and uses all or part of the free area as a new cell.

After setting the cell length, the cell securing unit 201
Are the reference counters A and B of the secured cells.
To 0 and the work flag to 0 (step S41
3). This makes the cell white. In the code for generating an object in the application program, assignment to the object pointer is usually indicated so as to point to the generated object. In this case, after step S413, the control mechanism 200 causes the pointer setting unit 202 to set the pointer. Is sent to the garbage collection apparatus 100 to cause pointer change handling processing to be performed (step S414).

<1-3-2. Change of pointer> Control mechanism 20
0 notifies the garbage collection device 100 of the pointer change through the pointer setting unit 202 when the code of assignment to the object pointer in the application program is to be interpreted. The pointer setting unit 202 also transmits the pointer values before and after the change when transmitting the pointer change.

The garbage collection device 100 performs pointer change handling processing when the pointer change is notified. FIG. 6 is a flowchart showing a pointer change handling process performed by the garbage collection device 100. When the pointer change is transmitted, the counter changing unit 110 of the garbage collection device 100 determines whether or not the pointer before the change points to the cell (step S421). The cell reference cancellation processing is performed based on the current pointer before change (step S422), and if it does not point to the cell, step S422
The cell reference cancellation processing of 422 is not performed. That is, if the pointer before the change is NULL, the cell reference cancellation processing is not performed. The cell reference cancellation processing will be described later with reference to FIG. 7.

Subsequently, the counter changing unit 110 determines whether or not the changed pointer points to the cell (step S4).
23) If the pointer does not point to a cell, the pointer change handling process ends. Also, in step S423,
When the changed pointer points to the cell, the counter changing unit 110 determines whether the reference counter A of the cell pointed to by the pointer is the MAX value by the counter maximum value determining unit 111 (step S424). ),
If it is not the MAX value, the reference counter A is incremented by 1 by the counter incrementing unit 112 (step S4).
25), and if it is the MAX value, step S425 is not performed.

After step S425 or when it is determined in step S424 that the value is the MAX value, the counter changing unit 110 determines whether the work flag of the cell holding the changed pointer is 2, that is, the cell. Is determined to be black (step S426), and if it is not black, the pointer change handling process ends. Step S4
When it is determined that the cell is black in 26, the counter changing unit 110 determines whether the work flag of the cell pointed by the changed pointer is 0, that is, whether the cell is white. The determination is made (step S427), and only when it is white, the work flag of the cell pointed by the changed pointer is changed from 0 to 1 (step S428).

Subsequent to steps S427 and S428, the counter changing unit 110 causes the counter maximum value judging unit 111 to judge whether or not the reference counter B of the cell pointed by the changed pointer is the MAX value (step S42).
9) If it is not the MAX value, the counter incrementing unit 112 increments the reference counter B by 1 (step S430), the pointer change handling process is terminated, and MAX is reached.
If it is a value, the pointer change handling process is terminated without performing step S430.

FIG. 7 shows a garbage collection apparatus 100.
6 is a flowchart showing a cell reference cancellation process performed by the above.
In the figure, in step S435, the cell reference cancellation processing is expressed recursively. First, the counter changing unit 110 causes the counter maximum value determining unit 111 to determine the reference counter A of the cell pointed to by the focused pointer is the MAX value based on the pointer focused on immediately before the cell dereference processing. It is determined whether or not (step S431).

Hereinafter, step S43 of the cell reference cancellation processing.
The pointer that is focused on when 1 is performed is referred to as a processing target pointer. In step S431, the reference counter A of the cell pointed to by the processing target pointer is set to M.
When it is determined that the value is not the AX value, the counter changing unit 11
For 0, the counter decrement unit 113 decrements the reference counter A by 1 (step S432), and then the counter zero determination unit 120 determines the reference counter A.
Is determined to be 0 (step S433).

If it is determined in step S433 that the reference counter A is 0, the cell dereference process (FIG. 7) is performed by sequentially focusing on the pointers to the cells held by the cells pointed to by the process target pointer. ) Is repeated (steps S434 and S435). As a result, step S435 is repeated by the number of pointers to the cell held by the cell pointed to by the processing target pointer. If the cell pointed to by the processing target pointer does not hold the pointer to the cell, the process of step S435 is omitted.

The cell releasing unit 130 releases the cell by setting the valid cell flag to 0 after repeating step S435 for the cell for which the reference counter A is determined to be 0 in step S433 (step S436). ), Thereby ending the cell reference cancellation processing. Further, when it is determined in step S431 that the reference counter A of the cell pointed to by the processing target pointer is the MAX value, and when it is determined in step S433 that the reference counter A is not 0, the counter changing unit 110 , It is determined whether or not the cell holding the processing target pointer is black (step S43).
7) If it is not black, end the cell reference cancellation processing,
If it is black, the counter maximum value determination unit 111 determines whether or not the reference counter B of the black cell has the MAX value (step S438).

When it is determined in step S438 that the reference counter B is not the MAX value, the counter changing unit 110 decrements the reference counter B by 1 by the counter decrementing unit 113 (step S43).
9) If the cell reference cancellation processing is ended and it is determined that the value is the MAX value, the cell reference cancellation processing is ended without performing step S439.

<1-3-3. Count and sweep processing>
Count-and-sweep instruction unit 210 of control mechanism 200
Is a relatively small amount of time per unit time for the CPU to execute the application program, and the memory area in the memory 300 where new cells can be allocated is reduced from a predetermined reference amount. Whether or not it is detected is detected, and if it is decreased, the garbage collection device 100 is controlled to perform the count and sweep process using the relatively short time. Note that the time allocation can be realized by, for example, configuring the count-and-sweep processing and the processing associated therewith as a thread separate from the application program, and appropriately distributing a so-called time slice value for each thread.

FIG. 8 shows a garbage collection system 100.
It is a flow chart which shows the count and sweep processing which is performed. When the count-and-sweep instruction unit 210 requests execution of the count-and-sweep process, the re-count unit 140 of the garbage collection device 100
First, the reference counter B for all cells is set to 0.
And the work flag is set to 0 (step S501). This makes all cells white.

Subsequent to step S501, the recount unit 140 sets the work flag to 1 for all cells directly pointed to by the root pointer to make the cells gray, and the reference counter B is not the MAX value. The reference counter B is incremented by 1 (step S50
2). Following step S502, the recount unit 140
Searches for a gray cell by following a pointer chain originating from the root pointer (step S503).

As a result of the search in step S503, the recounting unit 140 finds a gray cell (step S504). For each pointer in the gray cell that is searched for and pointing to the cell, If the cell pointed to by the pointer is white, step S506 that makes the white cell gray by changing the work flag of the cell from 0 to 1 and the reference counter B of the cell pointed to by the pointer must be the MAX value. For example, step S507 of incrementing the reference counter B by 1 is repeated (steps S505 to S507). However, if there is no pointer pointing to the cell in the gray cell that has been searched for, the processing of steps S506 and S507 is omitted.

For each pointer in the gray cell that has been found, steps S506 and S507 are performed by step S505.
After repeating, the recount unit 140 turns the gray cell into black (step S508),
Return to the processing of 503. That is, the search for another gray cell is started. In this way, steps S503 to S508 are repeated, and when the gray cell does not exist, the recount unit 140 proceeds to no branch in step S504, and steps S5 to S5 for all cells.
09-S512 are performed (step S509). That is, the recount unit 140 sequentially determines for each cell by the recount result zero determination unit 141 whether or not the reference counter B of the cell is 0 (step S510). The counter resetting unit 142 sets the reference counter A of the cell to the same value as the reference counter B and makes the cell white (step S512), and when it is 0, the cell releasing unit 130.
Resets the valid cell flag of the cell to 0 and releases the cell (step S511). When the processing from step S509 is performed on all cells in this way, the count and sweep processing is completed.

The count and sweep process is performed in parallel with the execution of the application program.
However, in the counter-and-sweep process, the application program is not executed during the execution of the single step shown in FIG. 8, and the application program is not executed between the start of execution of step S505 and the end of execution of step S508. Needs to be done. This is, for example, for the OS performing multitask control, the garbage collection device 10
0 is realized by declaring that the CPU occupies a single step or during execution of steps S505 to S508.

The progress of the above count and sweep process will be described below step by step with reference to FIGS. 9 to 13. FIG. 9 is a diagram exemplifying the content of cells and the relationship between cells immediately after the end of step S502 in the count and sweep process. Only six cells are shown here for ease of explanation.

Before execution of the count and sweep process, all the cells 11 to 16 have the valid cell flag set to 1.
Is valid, the reference counter A of the cell 11, the cell 13, the cell 14, and the cell 16 has the MAX value, and the reference counter A of the cell 12 and the cell 15 is 1. In the state shown in the figure, the reference counter B is first set for all the cells 11 to 16 by step S501 of the count and sweep process.
Is set to 0 and the work flag is set to 0. Then, in step S502, the reference counter B of the cell 11 directly pointed to by the root pointer 10 is increased to 1 and the work flag is set to 1. is there. At this time, only the cell 11 is gray and the cells 12 to 16 are white.

FIG. 10 is a diagram exemplifying the content of cells and the relationship between cells immediately after the completion of the first execution of step S508 in the count and sweep process. The state shown in the figure is based on the state shown in FIG.
The gray cell 11 is detected by 03, and the cells 12 and 15 pointed by the pointers in the cell are changed from white to gray, and the reference counter B is incremented by 1 (steps S504 to S507), and step S5.
This is the state at the time when the cell 11 is made black by 08.

FIG. 11 is a diagram exemplifying the contents of cells and the relationship between cells immediately after the execution of the second step S508 in the count and sweep process is completed. The state shown in the figure is based on the state shown in FIG.
The gray cell 12 is detected by 503, and the cells 13 and 16 pointed by the pointers in the cell are changed from white to gray and the reference counter B is set to 1
Increased (steps S504 to S507), step S
This is the state at the time when the cell 12 is made black by 508.

FIG. 12 is a diagram exemplifying the contents of cells and the relationship between cells immediately after proceeding to the no branch of S504 in the count and sweep processing. The state shown in the figure is based on the state shown in FIG.
This is the state at the time when the gray cell is no longer present by repeating the processing from S508 to S508. At this time, each cell indicates the number of times the cell is referenced by the reference counter B.

FIG. 13 is a diagram exemplifying the contents of cells and the relationship between cells at the end of the count and sweep process. The state shown in the figure is based on the state shown in FIG. 12, and by executing steps S509 to S511, the valid cell flag of the cell 14 whose reference counter B is 0 is released from 1 to 0, The reference counter B is copied to the reference counter A for the other cells. By this count and sweep process, cell 1 that is not referenced from anywhere
4 is released, and the reference counter A, which has been at the MAX value due to the reference being made 15 times or more, is reset to a value indicating the current number of times of reference to the cell.
Therefore, thereafter, in the pointer change handling process, the cell can be released based on the reference counter A when the reference counter A becomes 0.

<1-4. Consideration> Considering the change over time in the number of referenced cells in the cell lifetime, the number of cell references can be represented by a reference counter, for example, 300 times in the short time after cell generation, as shown in FIG. Although it may take a large value, it will eventually settle to a size that can be represented by a reference counter, such as around 10 times.

That is, in an application program created in a programming language of a type capable of creating an object having a variable-length data structure, such as Java language, the cells secured in the memory corresponding to the creation of the object are As shown in FIG. 29, a large number of references are made so that the reference counter A once overflows within a short period from the securing, but after that, the number of references to that cell is the reference counter A.
Settles down to the extent that does not overflow.

Therefore, the reference counter A temporarily reaches the MAX value in a short time after the generation of cells, but the count-and-sweep processing is performed at a stable stage, so that the number of referenced cells in the cell at that time is decreased. Is reset to the reference counter A, and thereafter, similar to the case of the normal reference counter method, control to immediately release the cell when the cell is no longer referenced from anywhere is realized. Will be possible.

According to this count-and-sweep processing, in addition to the effect similar to the mark-and-sweep method of releasing unnecessary cells that are not referenced from anywhere, the reference counter once overflows and becomes a reference count method. Even if a cell for which the release control corresponding to the above becomes impossible, if the number of referenced cells of the cell falls within the range that can be represented by the reference counter at the time of processing, that cell is thereafter referred to as the reference count method. The effect that it becomes possible to perform the release control of various cells is obtained.

The method shown in the first embodiment is
Compared with the conventional simple reference count method,
In the method described in the first embodiment, when there is a large difference between the peak value of the number of cells referred to in the initial stage and the value in the subsequent stable state, the area in the cell required for reference counting is more It can be said that this method has the potential to be small. <2. Second Preferred Embodiment> Hereinafter, a garbage collection device according to a second preferred embodiment of the present invention (hereinafter, referred to as “deformed garbage collection device”) will be described.

<2-1. Configuration> The modified garbage collection device has the same basic configuration as the garbage collection device 100 described in the first embodiment, but counts and counts by providing a work area in a cell and using the work area. The sweep process can be performed at higher speed. The functional components of the modified garbage collection device will be described below using the same reference numerals as the functional components of the garbage collection device 100 (see FIG. 1). Further, a control mechanism corresponding to the modified garbage collection device and corresponding to the control mechanism 200 shown in the first embodiment is referred to as a modification control mechanism, and the functional components thereof have the same reference numerals as the functional components of the control mechanism 200. It demonstrates using.

<2-2. Data> Hereinafter, a cell which is a processing target of the modified garbage collection device and which is a data unit used for storing data of an object in an application program will be described. FIG. 14 is a diagram showing a data structure of cells handled by the modified garbage collection device. It should be noted that one line in the figure corresponds to a word unit that is the basic word length of the computer.

The cell 2100 is composed of a plurality of words,
1-word header part and 1-word work area 2106
And a variable length data area 2107. here,
The header portion includes a valid cell flag area 2101, a cell length area 2102, a reference counter A area 2103, a reference counter B area 2104, and a work flag area 21.
And 05.

Valid cell flag area 2101, reference counter A area 2103 and reference counter B
The areas 2104 are the valid cell flag area 1101, the reference counter A area 1103, and the reference counter B area 11 shown in FIG. 2 in the first embodiment, respectively.
Since it is equivalent to 04, the description is omitted here.

The cell length area 2102 is one bit larger than the cell length area 1102 described in the first embodiment, and is a 22-bit area for storing a value indicating the cell length of the header portion, the work area, and the data area. Is. The cell length stored in this area is represented by the number of words, for example. The work flag area 2105 is a 1-bit area smaller than the work flag area 1105 described in the first embodiment, and stores a work flag used to indicate a state regarding a cell in the count and sweep process. The work flag takes a value of 0 or 1, and is initially set to 0 in the count and sweep process.

The work area 2106 is an area used for connecting each cell with a pointer chain, starting from a 1-word area provided in advance in the memory 300 for storing the work start cell address. In the count and sweep processing, when it is determined that the cell is connected by the pointer chain originating from the root pointer, the address of another cell is stored.

When the cell 2100 is not connected by the pointer chain from the work start cell address, NULL is stored in the work area 2106, and when it is connected by the pointer chain. If it is the end of the chain, a predetermined value for indicating the end, such as 0xFFFFFFFF (hereinafter,
It is called "end mark". ) Is stored and is connected by the pointer chain and is not the end of the chain, the address of the next cell is stored.

Further, the data area 2107 is equivalent to the data area 1106 shown in the first embodiment, and therefore its explanation is omitted here. FIG. 15 is a diagram exemplifying a pointer chain from the working head cell address 30 of the cell in the second embodiment. In the figure, the tip of the arrow indicates the cell pointed to by the address.

The working head cell address 30 is the cell a31.
Address of the cell a and the work area of the cell a31 is the cell b.
The address of 32 is stored, the work area of the cell b32 stores the address of the cell c33, and the end mark is stored in the work area of the cell c33.
Further, NULL is stored in the work area of the cell d34 which is out of the pointer chain.

In the second embodiment, the last-in first-out stack algorithm is used when connecting or disconnecting cells in the count-and-sweep process with respect to the pointer chain originating from the work start cell address 30. To use. Therefore, the cell indicated by the pointer chain starting from the work start cell address 30 is expressed as having the cell stored in the work stack. In addition, P the cell to the working stack
The expression USH means to insert a cell at the head of the pointer chain, and the expression POP the cell from the working stack means to remove the head cell of the pointer chain from the chain.

For example, in the state shown in FIG. 15, when the cell d34 is pushed to the working stack, the working head cell address is rewritten so as to indicate the address of the cell d34, and the cell a31 is stored in the working area of the cell d34. Will be stored. Immediately after that, the cell that can be POP from the working stack becomes the cell d34, and when the cell d34 is POP, the cell d34 is removed from the pointer chain, and the state returns to that shown in FIG. At the time of POP, NULL is set in the work area of the POP cell.

<2-3. Operation> Hereinafter, the operation of the modified garbage collection device that performs the garbage collection for the cells described above and the related deformation control mechanism that controls the interpretation and execution of the application program will be described. <2-3-1. Cell Generation> The transformation control mechanism that sequentially interprets the code of the application program and performs control for execution causes the cell securing unit 201 to perform cell generation processing when the code for object generation is an interpretation target.

FIG. 16 is a flowchart showing a cell generation process performed by the cell securing unit 201 in the transformation control mechanism. The cell securing unit 201 secures a cell having a size including the amount of object data to be stored in the cell, one word of the header portion and one word of the work area, and sets the valid cell flag of the cell to 1 (Step S611),
The cell length is set based on the size (step S6).
12). In securing this cell, the cell securing unit 201
Searches for a free area in which the valid cell flag is 0 in the memory 300, and uses all or part of the free area as a new cell.

After setting the cell length, the cell securing unit 201
Are the reference counters A and B of the secured cells.
Is set to 0, the work flag is set to 0, and the work area is set to NULL.
Is set (step S613). In the code for object generation in the application program, assignment to the object pointer is usually indicated so as to point to the generated object. In this case, after step S613, the transformation control mechanism causes the pointer setting unit 202 to set the pointer. Is transmitted to the modified garbage collection device, and pointer change handling processing is performed (step S614).

<2-3-2. Pointer Change> The pointer change handling process performed by the modified garbage collection device is basically the same as the pointer change handling process performed by the garbage collection device 100 described in the first embodiment (see FIG. 6). However, in the first embodiment, it is determined whether or not the work flag is 2 (step S426),
In the second embodiment, replacement is performed so as to determine whether or not the work flag is 1, and the point in which the work flag in the cell is changed to 1 in the first embodiment (step S428)
In the second embodiment, the cell is replaced with the working stack by PUSH. In the cell dereference process (see FIG. 7), it is similarly determined whether or not the work flag is 2 in the first embodiment (step S4).
37) is replaced so as to determine whether the work flag is 1 in the second embodiment.

<2-3-3. Count and sweep processing>
Counting and sweeping instruction section 210 of deformation control mechanism
Is a relatively small amount of time per unit time for the CPU to execute the application program, and the memory area in the memory 300 where new cells can be allocated is reduced from a predetermined reference amount. Whether or not it is detected is detected, and when it is decreased, control is performed so that the modified garbage collection device is caused to perform the count-and-sweep process using the relatively short time.

FIG. 17 is a flowchart showing the count-and-sweep process performed by the modified garbage collection device. When the count-and-sweep instruction unit 210 of the transformation control mechanism requests execution of the count-and-sweep process, the re-counting unit 140 of the transformation garbage collection device first sets the reference counter B for all cells to 0 and sets the work flag. It is set to 0 and NULL is set in the work area (step S701). The initial value of the working head cell address 30 is an end mark, and is the end mark at the time when step S701 is executed.

Subsequent to step S701, the recount unit 140 increments the reference counter B by 1 for all cells directly pointed to by the root pointer and sequentially pushes them to the working stack (step S70).
2). Here, PUSH is the start cell address for work 3
The value of 0 at the time of the PUSH is stored in the work area of the PUSH target cell, and
The target cell address is the working cell address 30
It is realized by setting to.

Subsequent to step S702, the recount unit 140 determines whether or not cells are stored in the working stack (step S703). Recount unit 140
If the value of the work head cell address 30 is other than the end mark, it is determined that the cell is stored in the work stack, and if it is the end mark, it is determined that the cell is not stored in the work stack. .

When it is determined in step S703 that a cell is stored in the work stack, the recount unit 140 pops one cell from the work stack.
Then, the working flag of the POPed cell is set to 1 (step S704), and it is determined whether or not the cell is valid by referring to the valid cell flag of the cell (step S70).
5).

Here, the POP sets the contents of the work area at the time of the POP of the cell pointed to by the work start cell address 30 in the work start cell address 30, and
It is realized by storing NULL in the work area of the cell. When it is determined in step S705 that the cell is valid, the recount unit 140 sets 1 for each pointer in the cell that points to the cell, unless the reference counter B of the cell pointed to by the pointer is the MAX value.
If the work flag of the cell pointed to by the pointer is 0 and the work area is NULL, the cell pointed to by the pointer is added to the work stack in step S707.
Perform USH step S708 (step S70
6-S708). However, in step S704, the PO
If there is no pointer to the cell in the P cell,
The processes of steps S707 and S708 are omitted.

After steps S706 to S708, or when it is determined in step S705 that the cell is not valid, the recounting unit 140 returns to the determination whether the cell is stored in the working stack again (step S703).
In step S703, when it is determined that no cells are stored in the work stack, the recount unit 14
0 indicates step S709 for each cell for all cells.
S712 is performed (step S709).

That is, the recounting unit 140 sequentially determines the recounting result zero determining unit 14 for each of all cells.
It is determined by 1 whether or not the reference counter B of the cell is 0 (step S710), and if it is not 0, the counter resetting unit 142 sets the reference counter A of the cell to the same value as the reference counter B, and The work flag is set to 0 (step S712), and when it is 0, the cell releasing unit 130 sets the valid cell flag of the cell to 0 and releases the cell (step S711). When the processing from step S709 is performed on all cells in this way, the count and sweep processing is completed.

The count and sweep process is performed in parallel with the execution of the application program.
However, in the count and sweep process, the application program is not executed during execution of the single step shown in FIG. 17, and further, step S704.
It is necessary to prevent the application program from being executed during the period from the start of execution of step 1 to the end of step S708. This is realized by, for example, declaring to the OS that performs multitask control that the modified garbage collection device occupies the CPU during a single step or during execution of steps S704 to S708.

The progress of the above count and sweep processing will be described below step by step with reference to FIGS. FIG. 18 is a diagram exemplifying the content of cells and the relationship between cells immediately after the end of step S701 in the count and sweep process. Only six cells are shown here for ease of explanation.

Before execution of the count and sweep processing, all the cells 41 to 46 have the valid cell flag set to 1.
Is valid, the reference counter A of the cell 41, the cell 43, the cell 44, and the cell 46 is the MAX value, and the reference counter A of the cell 42 and the cell 45 is 1. In the state shown in the figure, the reference counter B is first set for all the cells 41 to 46 by step S701 of the count and sweep process.
Is set to 0 and the work flag is set to 0. The value of the working top cell address at this point is the end mark.

FIG. 19 is a diagram exemplifying the contents of cells and the relationship between cells immediately after the execution of step S702 in the count and sweep process. The state shown in the figure is based on the state shown in FIG.
For the cell 41 pointed to by the root pointer by, the reference counter B is incremented to 1 and is pushed to the working stack.

FIG. 20 is a diagram exemplifying the content of cells and the relationship between cells immediately after the repetition processing of step S706 in the count and sweep processing is completed. In the state shown in the figure, on the premise of the state shown in FIG. 19, the cell 41 is popped and the work flag is set to 1 in step S704, and the cells 42 and 45 pointed to by the pointer held by the cell 41 are sequentially used for work. In this state, the stack is PUSHed and the reference counter B is incremented by one.

FIG. 21 is a diagram exemplifying the content of cells and the relationship between cells immediately after step S706 is finished in the count and sweep processing. The state shown in the figure is based on the state shown in FIG.
The cell 45 is POPed and the work flag is set to 1, and the cell 46 pointed by the pointer held by the cell 45 is PUSHed to the work stack and the reference counter B is incremented by one.

FIG. 22 is a diagram exemplifying the contents of cells and the relationship between cells immediately after proceeding to the no branch of step S703 in the count and sweep process. The state shown in the figure is based on the state shown in FIG.
This is the state at the time when there are no cells stored in the working stack by repeating the processing of 703 to S708. At this time, each cell indicates the number of times the cell is referenced by the reference counter B.

After the state shown in FIG. 22, step S
709 to S712 are performed, the cell 44 is released by setting the valid cell flag to 0, and the reference counter A is reset to the same value as the reference counter B in the other cells. <2-4. Consideration> According to the method in which the work area is provided in each cell and the work stack is used, the first embodiment is described.
It is possible to shorten the time required for the process of searching for the gray cell as shown in, and to perform the count and sweep process at high speed.

Even when the conventional reference count method is used, the mark-and-sweep method is also used in order to solve the problem that unnecessary cells cannot be released when the chain of pointers to cells loops. In some cases, in order to perform the mark-and-sweep method processing in parallel with the operation of the application program, the embodiment using the work stack is effective. 1 for each cell to realize this working stack
Compared with the case where the conventional reference count method and the mark-and-sweep method are used in combination with the mode in which the word work area is provided, the method shown in the second embodiment is effective at the initial stage of the number of referenced cells. It can be said that this method has a possibility that the area in the cell required for reference counting can be made smaller when the difference between the peak value of 1 and the value in the later stable state is large. <3. Third Preferred Embodiment> Hereinafter, a garbage collection device according to a third preferred embodiment of the present invention (hereinafter, referred to as “second modified garbage collection device”) will be described.

<3-1. Configuration> The second modified garbage collection device has the same basic configuration as the garbage collection device 100 described in the first embodiment,
Even if only one reference counter is used for each cell instead of two reference counters A and B, the count and sweep processing can be performed based on the reference counting method. The functional components of the second modified garbage collection device will be described below using the same reference numerals as the functional components of the garbage collection device 100 (see FIG. 1). Also,
A control mechanism corresponding to this second modified garbage collection device and corresponding to the control mechanism 200 shown in the first embodiment is referred to as a second modified control mechanism, and its functional components are the same as those of the control mechanism 200. Description will be given using reference numerals.

<3-2. Data> Hereinafter, a cell that is a data unit used as a processing target of the second modified garbage collection device and used to store data of an object in an application program will be described. FIG. 23 is a diagram showing a data structure of cells handled by the second modified garbage collection device. It should be noted that one line in the figure corresponds to a word unit that is the basic word length of the computer.

The cell 3100 is composed of a plurality of words,
It consists of a 1-word header section and a variable-length data area 3105. Here, the header portion is a valid cell flag area 3
101, a cell length area 3102, a reference counter area 3103, and a work flag area 3104. Valid cell flag area 3101 and work flag area 3
104 are valid cell flag areas 1101 and work flag areas 1105 shown in FIG. 2 in the first embodiment, respectively.
Therefore, the description is omitted here. In the third embodiment, as in the first embodiment, the work flag of the cell is 0, the cell is white, the work flag is 1, and the cell is gray.
The fact that the work flag is 2 is also expressed as the cell being black.

The cell length area 3102 is 4 bits larger than the cell length area 1102 described in the first embodiment, and is a 25-bit area for storing a value indicating the cell length of the header portion, the work area, and the data area. Is. The cell length stored in this area is represented by the number of words, for example. The reference counter area 3103 is a 4-bit area for storing a reference counter. The reference counter can represent a number from 0 to 15. However, the maximum value of 15 means that the reference counter overflows because the number of times the cell is referenced is once more than 15. Used as an indicator.

The data area 3105 is equivalent to the data area 1106 shown in the first embodiment, and therefore its explanation is omitted here. Further, in the second modified garbage collection device, in order to indicate whether or not the count and sweep process is being executed, one bit in the memory is set as a count and sweep executing flag, and if it is being executed, the count and sweep executing process is executed. The middle flag is turned on, and if not being executed, it is turned off.

<3-3. Operation> Hereinafter, an operation of the second modified garbage collection device that performs the above-described garbage collection on the cell and the related second modified control mechanism that controls the interpretation and execution of the application program will be described. <3-3-1. Cell Generation> The second modification control mechanism that sequentially interprets the code of the application program and performs control for execution causes the cell securing unit 201 to perform the cell generation process when the code for object generation is the interpretation target.

This cell generation process is basically the same as the cell generation process (see FIG. 5) shown in the first embodiment. However, the step of setting “reference counters A and B to 0” in step S413 is “reference counter to 0”.
Should be read as <3-3-2. Pointer change> The second modification control mechanism notifies the second modification garbage collection device of the pointer modification through the pointer setting unit 202 when the code of assignment to the object pointer in the application program is to be interpreted. The pointer setting unit 202
When transmitting a pointer change, will also tell the pointer value before and after the change.

The second modified garbage collection device performs pointer change handling processing when the pointer change is notified. FIG. 24 is a flowchart showing pointer change handling processing performed by the second modified garbage collection device.
When the change of the pointer is transmitted, the counter changing unit 110 of the second modified garbage collection device determines whether or not the pointer before the change points to the cell (step S82).
1) If it points to a cell, cell reference cancellation processing is performed based on the focused pointer before change (step S822). If it does not point to a cell, cell reference cancellation in step S822. No processing is done. That is, if the pointer before the change is NULL, the cell reference cancellation processing is not performed. The cell reference cancellation processing will be described later with reference to FIG.

Then, the counter changing unit 110 determines whether or not the changed pointer points to the cell (step S8).
23) If the pointer does not point to a cell, the pointer change handling process ends. Also, in step S823,
If the changed pointer points to a cell, the counter changing unit 110 refers to the count-and-sweep executing flag to determine whether the count-and-sweep process is being executed (step S824). If it is being executed, it is determined whether or not the cell holding the changed pointer is black, that is, the work flag of the cell is 2 (step S827).

If it is determined in step S827 that the cell holding the changed pointer is not black,
The counter change unit 110 ends the pointer change handling process. When it is determined in step S827 that the cell holding the changed pointer is black, the counter changing unit 110 determines whether the work flag of the cell pointed to by the changed pointer is 0, that is, It is determined whether or not the cell is white (step S828), and only when the cell is white, the work flag of the cell pointed by the changed pointer is changed from 0 to 1 (step S829).

After steps S828 and S829, or when it is determined in step S824 that the count-and-sweep process is not being executed, the counter changing unit 110 causes the counter maximum value determining unit 111 to point to the pointer after the change. The cell reference counter is MA
It is determined whether it is the X value (step S825), and MA
If it is not the X value, the counter increment unit 112 increments the reference counter by 1 (step S82).
6) The pointer change handling process ends, and if it is the MAX value, the pointer change handling process ends without performing step S826.

FIG. 25 is a flow chart showing the cell reference cancellation processing performed by the second modified garbage collection device. In the figure, in step S836, the cell reference canceling process is expressed recursively. First, the counter changing unit 110 refers to the count-and-sweep execution flag to determine whether the count-and-sweep processing is being executed (step S831), and if it is not being executed, performs the cell reference cancellation processing. Based on the pointer that was focused on immediately before, the counter maximum value determination unit 111
Thus, it is determined whether or not the reference counter of the cell pointed by the focused pointer is the MAX value (step S832).

In the following, step S83 of the cell reference cancellation processing.
The pointer that is focused on when 1 is performed is referred to as a processing target pointer. In step S832, the reference counter of the cell pointed to by the process pointer is MA
When it is determined that the value is not the X value, the counter changing unit 110
The counter decrement unit 113 decrements the reference counter by 1 (step S833), and then the counter zero determination unit 120 determines whether the reference counter has become 0 (step S834).

If it is determined in step S834 that the reference counter is 0, the cell reference cancellation processing is performed by sequentially focusing on the pointers to the cells held by the cells pointed to by the processing target pointer (FIG. 25). Is repeated (steps S835 and S836). As a result, step S836 is repeated by the number of pointers to the cell held by the cell pointed to by the processing target pointer. If the cell pointed to by the processing target pointer does not hold the pointer to the cell, the process of step S836 is omitted.

The cell releasing unit 130 releases the cell by resetting the valid cell flag to 0 after repeating step S836 for the cell for which the reference counter is determined to be 0 in step S834 (step S837). Thus, the cell reference cancellation processing ends. If it is determined in step S831 that the count and sweep process is being executed,
The counter changing unit 110 determines whether the cell holding the processing target pointer is black (step S83).
8) If it is black, the counter maximum value determination unit 1
According to 11, it is determined whether or not the reference counter of the cell pointed to by the processing target pointer is the MAX value (step S839).

In step S839, if the counter maximum value determination unit 111 determines that the reference counter of the cell pointed to by the processing target pointer is not the MAX value,
The counter decrement unit 113 sets the reference counter to 1
Decrease (step S840), and the cell reference cancellation processing is thereby completed. Further, in step S832, the reference counter of the cell pointed to by the processing target pointer is MA.
If it is determined to be the X value, it is determined in step S834 that the reference counter is not 0, and it is determined in step S838 that the cell holding the processing target pointer is not black, When it is determined in S839 that the reference counter of the cell pointed to by the processing target pointer is the MAX value, the cell reference cancellation processing ends.

<3-3-3. Count and sweep processing>
Count and sweep instruction unit 21 of the second deformation control mechanism
0 means that a memory area in which a cell can be newly allocated in the memory 300 is smaller than a predetermined reference amount by using a relatively short time per unit time for the CPU to execute the application program. Whether or not it is decreasing is detected, and if it is decreasing, the second modified garbage collection device is controlled to perform the count-and-sweep process using the relatively short time.

FIG. 26 is a flow chart showing the count and sweep process performed by the second modified garbage collection device. When the count-and-sweep instruction unit 210 requests execution of the count-and-sweep process,
Re-counting unit 14 of second modified garbage collection device
For 0, first set the count and sweep execution flag to O.
N (step S851), the reference counters for all cells are set to 0, and the work flags are set to 0 (step S852). This makes all cells white.

Subsequent to step S852, the recounting unit 140 sets the work flag to 1 to make the cells gray for all the cells directly pointed to by the root pointer, and sets the reference counter if it is not the MAX value. Increment the counter by 1 (step S85
3). Following step S853, the recount unit 140
Searches for a gray cell by following a pointer chain originating from the root pointer (step S854).

As a result of the search in step S854, the recount unit 140 finds a gray cell (step S855), and for each pointer in the gray cell found that points to the cell, If the cell pointed to by the pointer is white, step S857 of making the white cell gray by changing the work flag of the cell from 0 to 1, and if the reference counter of the cell pointed to by the pointer is not the MAX value The step S858 of incrementing the reference counter by 1 is repeated (steps S856 to S858). However, if there is no pointer that points to the cell in the gray cell that was searched for, step S
The processes of 857 and S858 are omitted.

For each pointer in the searched gray cell, steps S857 and S858 are performed by step S856.
After repeating, the recount unit 140 turns the gray cell into black (step S859),
Returning to the processing of 854. That is, the search for another gray cell is started. In this way, steps S854 to S859 are repeated, and when the gray cell does not exist, the recount unit 140 proceeds to no branch in step S855, and step S8 for each cell for all cells.
60 to S862 are performed (step S860). That is, the recount unit 140 sequentially determines whether the reference counter of the cell is 0 by the recount result zero determination unit 141 for each of all cells (step S861), and only when it is 0, the cell The releasing unit 130 sets the valid cell flag of the cell to 0 and releases the cell (step S862). After repeating the process in step S860 for all cells in this way, the second modified garbage collection device turns off the count-and-sweep execution flag (step S863),
Ends the count and sweep process.

The count and sweep processing is performed in parallel with the execution of the application program.
However, in the count and sweep process, the application program is not executed during execution of the single step shown in FIG. 26, and further, step S856.
It is necessary to prevent the application program from being executed during the period from the start of execution to the end of execution of step S859. This is realized by, for example, declaring to the OS that performs multitask control that the second modified garbage collection device occupies the CPU during a single step or during execution of steps S856 to S859.

<3-4. Consideration> According to the method in which only one reference counter is used for each cell as described above, during the execution of the count and sweep process,
Although it is not possible to immediately release cells that are no longer referenced by changing the pointer, the area required for reference counting is smaller than the method that uses two reference counters, so there are many bits in the cell length area. Can be assigned, and other information can be included in the header portion of one word. <4. Supplement> The garbage collection device according to the present invention has been described above using the first to third embodiments.
Of course, the present invention is not limited to such an embodiment. That is, (1) In the first to third embodiments, the garbage collection is performed by the cooperation of the garbage collection device and the control mechanism, but since these are realized by software, they are clearly separated. There is no need, the mutual function sharing may be changed, and the garbage collection device may include some functions of the control mechanism. (2) In the first to third embodiments, the reference counter is composed of 4 bits that can represent a number of 0 to 15,
Although the number of referents up to is counted, and the value of 15 represents the overflow of the counter, the size of the reference counter is not limited to this. Basically, it is possible to count the number of cells to be referred to when a certain amount of time has passed since the generation of cells, in other words, a stable value (see FIG. 29) in a steady state rather than at peak time, without overflow. It is appropriate to set the peak value to a small size that cannot be counted. Since the stable value has a surface depending on the structure of the application program, the reference counter may be appropriately determined by assuming the application program to be executed. For example, when the stable value is about 20, a suitable reference counter is about 5 bits that can represent a number of 0 to 31. (3) The size of the cell length area in each cell shown in the first to third embodiments is merely an example. For example, the size of the cell length area is reduced and other management information or the like is added. It may be included in the cell. (4) In the first to third embodiments, the count and sweep process is executed when the memory shortage is detected. However, the present invention is not limited to this, and the count and sweep process is simply executed periodically. It may be that. Alternatively, for example, the number of cells in which the reference counter has the MAX value may be grasped, and the count and sweep process may be executed when the number becomes larger than a predetermined reference value.

The count-and-sweep process is a thread separate from the application program and is controlled so that the application program operates with a small time allocation. A method of temporarily interrupting the execution of the program and performing the count and sweep processing from the beginning to the end may be used. (5) In the first to third embodiments, the data type information and the data are stored in the cell data area, but the present invention is not limited to this, and the contents of the data area are stored in the data area. It is sufficient if it is possible to determine whether the stored data is a pointer to a cell. For example, by storing only data without including the data type in the data area, and analyzing the value of the data based on a predetermined rule regarding the address range where the cell is located, the data is You may make it determine whether it is a pointer to a cell. (6) Step S512 of FIG. 8 in the first embodiment,
In step S712 of FIG. 17 in the second embodiment, the reference counter B is set to the reference counter A.
However, the reference counter A may be set to the same value as the value of the reference counter B only when the reference counter A has the MAX value. (7) In the second embodiment, the work stack is realized by providing a work area in a cell and extending a pointer chain. However, a continuous stack area is provided in a memory area different from that used for the cell. Alternatively, the pointers to the cells may be loaded or unloaded, that is, PUSH or POP may be performed. (8) The count-and-sweep process in the garbage collection device shown in the first and second embodiments is predicted by design as an average period from the time when the cell is first reserved and the time when the cell is no longer referenced. The garbage collection device may be constructed so that the repetitive execution is started in a cycle shorter than the period. By doing this, for cells with an average lifetime, even if the reference counter overflows after the cells are secured, the reference is re-referenced by the count-and-sweep process until the cells are no longer needed. The counter returns to a valid value, and the count-and-sweep process works particularly effectively. The period from when the cell is first referenced to when it is no longer referenced is measured and calculated by the internal or external mechanism of the garbage collection device during execution of the application program. The garbage collection device may determine the execution start timing of the count and sweep process depending on the period. (9) Although it is assumed that the route pointers shown in the first to third embodiments are not changed, in order to make them changeable, for example, the region holding the route pointer is configured as one cell, At the start of counting and sweeping, the work flag of this cell is set to black, or the cell pointed to by the changed root pointer is white during the pointer changing process described in the first embodiment or the like. In that case, it is advisable to adopt a method of performing a process of changing the cell to gray. (10) Processing procedure of the garbage collection device and the control mechanism shown in the first to third embodiments (see FIGS.
It is also possible to record a computer program for causing a computer or information home appliance to execute the procedures shown in FIGS. 17 and 24 to 26) in a recording medium or to distribute and distribute the program through various communication paths. . Such recording media include IC cards, optical disks, flexible disks, ROMs and the like. The distributed or distributed computer program is provided for use by being installed in a computer or an information home electric appliance, and the computer or the information home electric appliance executes the computer program, and is shown in the first to third embodiments. You will be able to perform such garbage collection.

[0139]

Effect of the Invention <5. Verification of Effect of Garbage Collection Device According to First Embodiment> Hereinafter, a simulation performed to verify the effect of garbage collection (hereinafter referred to as “new garbage collection”) by the count-and-sweep process described in the first embodiment. The contents and results of the experiment will be briefly described.

This simulation experiment was carried out by comparing the new garbage collection with the garbage collection (hereinafter referred to as "old garbage collection") by a method that is a partial modification of the conventional counter-limited reference counting method described above. Here, the old garbage collection omits the processing when the reference counter overflows, that is, the processing such as copying the cell to a specific area, from the counter-limited reference counting method, and counts up and down the overflowed reference counter. It is excluded from the target, and the garbage collection processing by the mark-and-sweep method is added.

<5-1. Experiment contents> Under the situation that the application program creates a single size object (cell) at regular time intervals, garbage is generated by mark-and-sweep processing or count-and-sweep processing each time the amount of memory occupied by the object becomes constant. The collection is executed and the frequency of garbage collection is checked.

Here, it is assumed that steps are used as a unit of time and the application program generates 10 objects in 100 steps. Also,
It is assumed that the number of referenced objects in the lifetime of one object changes with time as shown in FIG. In addition, the total amount of memory is the size of 300 objects, and the execution timing of garbage collection is
It is assumed that the memory amount occupied by the object reaches 90% of the total memory amount.

The header part of the cell in the old garbage collection has a valid cell flag area (1 bit), a cell length area (25 bits) and a reference counter area (4 bits).
Bit) and work flag (2 bits), the header part of the cell in the new garbage collection is a valid cell flag area (1 bit), cell length area (21 bits), reference counter A area (4 bits). , A reference counter B area (4 bits) and a work flag (2 bits), a total of 32 bits.

<5-2. Experimental Results> FIG. 31 is a diagram showing temporal changes in the amount of unreleased memory (the number of objects occupying the memory) in the simulation experiment. As is clear from the figure, the execution frequency of the new garbage collection is lower than that of the old garbage collection.

According to this experiment, the number of executions of garbage collection up to 30,000 steps is 46 in the old garbage collection and 11 in the new garbage collection. When the amount of work of the mark-and-sweep process and the count-and-sweep process at this time are estimated and verified based on the number of memory accesses derived from each algorithm, the new garbage collection is about 40% of the old garbage collection. It was calculated to be the amount of work.

Therefore, compared with the old garbage collection, the new garbage collection does not adversely affect the execution performance of the application program, and
It can be said that this method enables efficient collection of unnecessary cells. <6. EFFECTS OF THE INVENTION> As is clear from the above description, the garbage collection device according to the present invention provides a referenced counter provided in each memory cell when the reference state to the memory cell is changed by the execution of the application program. Reference count means for performing a garbage collection by the reference count method by using the
For the above memory cells, independent count means for checking the number of actually referenced memory cells, and setting means for setting the number of the check result by the independent count means in the referenced counter of the corresponding memory cell. And is provided.

As a result, even if the referenced counter overflows, the number of cells being referenced is actually counted and set again in the referenced counter, so that the referenced counter has a correct value. Then, when the pointer is changed by the garbage collection of the reference counting method and the cell is no longer referenced from anywhere, the cell is immediately released. As shown in FIG. 29, in the case where the number of cells referred to largely fluctuates with time, such as when the number of cells referred to reaches a peak value and then settles to a stable value with time, the number of referred Even if the counter is configured with a small number of bits that can represent a stable value but not a peak value, the present invention enables garbage collection by the reference counting method.

Here, the referenced counter provided in each memory cell is composed of a predetermined bit number of less than one word for indicating the referenced number of the memory cell, and the reference counting means is an application. When the reference state of the memory cell is changed by the execution of the program and the value of the referenced counter of the memory cell is smaller than the maximum value that can be represented by the predetermined number of bits, the referenced counter is affected by the change. The reference count is incremented or decremented to release the memory cell when the value of the referenced counter reaches 0, and the independent count means is configured to perform the above-mentioned operation for at least each memory cell whose referenced counter has the maximum value. A survey may be conducted.

As a result, in the reference counting method, when the referenced counter of the cell overflows, that is, when the referenced counter has already reached the maximum value, the counter is not incremented or decremented. Although the cell that is no longer referred to is not released, the referenced counter can be set anew by the independent counting means and the setting means so as to actually indicate the referenced number of the cell. If it is no longer referenced by anyone when you change it, it will be released immediately. By releasing the cell, the memory area allocated to the cell can be used for generating a new cell.

Further, in the memory cell, there is provided a check counter having a predetermined number of bits for use in checking by the independent counting means, and the independent counting means is
After the initialization process for setting the investigation counter of the investigation target memory cell to 0, the investigation counter for each memory cell pointed to directly from the predetermined root pointer or through the pointer chain is set to the predetermined number of bits. The investigation is performed by performing a counting process that increases so as to indicate the number actually pointed to, within a range that does not exceed the maximum value that can be expressed, and the setting unit, for each memory cell, the investigation counter of the memory cell. The value of may be set in the referenced counter.

This makes it possible to easily realize the process of counting the number of actually referenced cells. Here, the referenced counter corresponds to the reference counter A shown in the embodiment, and the investigation counter corresponds to the reference counter B. Further, in the memory cell, there is provided a work flag for indicating which one of the first stage, the second stage and the third stage the investigation state by the independent counting means is, and the independent counting means are all Value is set to the work flag of the memory cell, and the value indicating the second step is set to the work flag of the memory cell pointed to by the root pointer, and the work flag indicating the second step is set. As long as there is a memory cell including, the memory cell is sequentially focused and the following count-up processing is performed to perform the count processing, and the count-up processing sets the work flag of the focused memory cell to the third stage. When the memory cell includes a pointer to one or more other memory cells, the check counters for all the other memory cells are set to the maximum value. As long as the value does not exceed the value, the value is incremented by 1, and for the other memory cells whose work flag indicates the first stage, it is a process of setting the value indicating the second stage in the work flag, and the reference counting means. , When the pointer included in the memory cell including the work flag indicating the third stage is changed by the execution of the application program, the investigation counter of the memory cell pointed to by the pointer before the change is decremented by 1 and The counter for checking the memory cell pointed to by 1 is incremented by 1 as long as it does not exceed the maximum value, the independent count means performs the check in parallel with the execution of the application program, and while the count-up processing is being executed. The execution of the application program may be suppressed.

As a result, the application program can be operated between the start and the end of the investigation of the number of cells actually referenced. A working flag is provided in the memory cell to indicate whether the investigation state by the independent counting means is in the first stage or the second stage. The independent counting means stores the address of the memory cell. Using the algorithm for storing in the stack, the work flags of all memory cells are set to values indicating the first stage, and subsequently, the addresses of the memory cells pointed to by the root pointer are stacked on the stack, and the memory cells are stacked on the stack. The count processing is performed by executing the count up processing shown below as long as the addresses of
A value indicating the second stage is set in the work flag of the memory cell indicated by the address fetched from the stack, and when the memory cell includes a pointer to one or more other memory cells, all the other memory cells This is a process of incrementing the check counter by 1 as long as it does not exceed the maximum value, and stacking the address of the other memory cells whose work flag indicates the first stage on the stack. When the pointer included in the memory cell including the work flag indicating the second stage is changed by the execution of the application program, the counter for decrementing the investigation counter of the memory cell pointed to by the pointer before the change is decremented by 1 and is changed. Increases the counter for checking the memory cell pointed to by the subsequent pointer by 1 as long as it does not exceed the maximum value , The independent counting unit performs in parallel the investigation and execution of the application program, during execution of the counting up process may be suppressed execution of the application program.

As a result, it becomes possible to perform a high-speed check of the number of actually referenced cells, and this check and the execution of the application program can be performed in parallel. Further, the garbage collection device further comprises a releasing means for releasing a memory cell whose number of the inspection result by the independent counting means is 0, and the setting means, when the number of the inspection result is 1 or more. The above setting may be performed only in some cases.

As a result of the investigation of the number of actually referenced cells, it is possible to release the cells whose referenced number is 0. When the chain of pointers to cells is looping, cells cannot be released only by the reference count method, but this garbage collection device makes it possible to release unnecessary cells that cannot be traced from the root pointer. Become.

Further, the independent counting means is arranged so that each memory cell secured and referred to by the execution of the application program is shorter than the time estimated from the average time from the reference to the complete non-reference. Further, the investigation may be performed, and the setting means may perform the setting each time the investigation is performed by the independent counting means.

As a result, for more than half of the cells, even if the reference count method cannot be used once due to the overflow of the referenced counter after it has been secured, the reference count is not reached within the period until the cells are no longer needed. Since the garbage collection by the method can be utilized and the cell can be released immediately when the cell is no longer needed, the practicality of the garbage collection apparatus is enhanced.

Further, the garbage collection apparatus according to the present invention is provided with a referenced counter having a predetermined number of bits of less than one word for indicating the referenced number of the memory cell in each memory cell, so that the application program When the reference state of the memory cell is changed by execution, if the referenced counter of the memory cell is a value smaller than the maximum value that can be represented by the predetermined number of bits, the referenced counter is changed according to the change. The reference count method of performing garbage collection and the execution of the application program independently of each other by a reference count method of increasing or decreasing as indicated by For a memory cell, check the number of times the memory cell is actually referenced. The unreferenced counter for each memory cell pointed directly from the predetermined root pointer or via the pointer chain after the initialization processing for setting the referenced counter of the memory cell under investigation to 0. A reference count means for performing a count process of increasing to show a number actually pointed to within a range not exceeding a maximum value that can be represented by the predetermined number of bits, wherein the reference count means is It is characterized in that the memory cells are not released during the investigation.

As a result, in the reference counting method, when the referenced counter of the cell overflows, that is, when the referenced counter has already reached the maximum value, the counter is not incremented or decremented. Although the cell that is no longer referred to is not released, the reference counter can be set anew by the independent counting means to actually indicate the reference number of the cell. Will also be released immediately if no longer referenced. Further, since the referenced counter is used for counting the number of referenced cells in the actual cell by the independent counting means,
It is not necessary to provide a counter dedicated to this counting.

The predetermined number of bits may be set so that the maximum value that can be represented by the predetermined bits is smaller than the value expected to be the peak value of the number of referenced memory cells. As a result, the area of the counter for reference count can be made small. Therefore, when providing the information for managing the cell in word units in the cell, the area of the counter is made smaller by For example, it becomes possible to store cell management information such as cell length in a cell having a larger size than in the past, and thereby, for example, to increase the cell size that is allowed to be secured for an application program. It will be possible.

[Brief description of drawings]

FIG. 1 is a configuration diagram of a garbage collection device 100 according to a first embodiment of the present invention.

FIG. 2 is a diagram showing a data structure of a cell.

FIG. 3 is a diagram showing how cells are assigned to a partial area of a memory 300.

FIG. 4 is a diagram exemplifying the contents of cells and relationships between cells at a certain time point.

5 is a flowchart showing a cell generation process performed by a cell securing unit 201. FIG.

FIG. 6 is a flowchart showing pointer change handling processing performed by the garbage collection device 100.

FIG. 7 is a flowchart showing a cell reference cancellation process performed by the garbage collection device 100.

8 is a flowchart showing a count and sweep process performed by the garbage collection device 100. FIG.

FIG. 9 is a diagram exemplifying the content of cells and the relationship between cells immediately after the end of step S502 in the count and sweep process.

FIG. 10 is a diagram exemplifying the content of cells and the relationship between cells immediately after the first execution of step S508 in the count and sweep processing is completed.

FIG. 11 is a diagram exemplifying the content of cells and the relationship between cells immediately after the execution of step S508 for the second time in the count and sweep processing is completed.

FIG. 12: S50 in count and sweep processing
It is the figure which illustrated the content of the cell and the relationship between cells immediately after advancing to the branch of 4no.

FIG. 13 is a diagram exemplifying the content of cells and the relationship between cells at the end of the count and sweep process.

FIG. 14 is a diagram showing a data structure of a cell handled by a modified garbage collection device.

FIG. 15 is a diagram exemplifying a pointer chain from a working head cell address 30 of a cell according to the second embodiment.

FIG. 16 is a flowchart showing a cell generation process performed by the cell securing unit 201 in the deformation control mechanism.

FIG. 17 is a flowchart showing a count-and-sweep process performed by the modified garbage collection device.

FIG. 18 is a diagram exemplifying the content of cells and the relationship between cells immediately after the end of step S701 in the count and sweep process.

FIG. 19 is a diagram exemplifying the content of cells and the relationship between cells immediately after the end of execution of step S702 in the count and sweep processing.

FIG. 20 is a diagram exemplifying the content of cells and the relationship between cells immediately after the repetition processing of step S706 in the count and sweep processing is completed.

FIG. 21 is a diagram exemplifying the content of cells and the relationship between cells immediately after step S706 is finished in the count and sweep process.

FIG. 22 is a diagram exemplifying the content of cells and the relationship between cells immediately after proceeding to the no branch of step S703 in the count and sweep processing.

FIG. 23 is a diagram showing a data structure of a cell handled by the second modified garbage collection device.

FIG. 24 is a flowchart showing pointer change handling processing performed by the second modified garbage collection device.

FIG. 25 is a flowchart showing cell reference cancellation processing performed by the second modified garbage collection device.

FIG. 26 is a flowchart showing a count-and-sweep process performed by the second modified garbage collection device.

FIG. 27 is a diagram for explaining a conventional mark-and-sweep method.

FIG. 28 is a diagram for explaining a conventional reference counting method.

FIG. 29 is a graph showing changes over time in the number of references to a typical cell in Java.

FIG. 30 is a graph showing a temporal change in the number of references to cells, which is a premise in a simulation experiment.

FIG. 31 is a diagram showing a temporal change in the amount of unreleased memory (the number of objects occupying memory) by a simulation experiment.

[Explanation of symbols]

100 garbage collection device 110 counter changing unit 111 maximum counter value determining unit 112 counter increasing unit 113 counter decreasing unit 120 counter zero determining unit 130 cell releasing unit 140 recounting unit 141 recounting result zero determining unit 142 counter resetting unit 200 control mechanism 201 cell securing unit 202 pointer setting unit 210 count and sweep instructing unit 300 memory 1100, 2100, 3100 cell 1101, 2101, 3101 valid cell flag area 1102, 2102, 3102 cell length area 1103, 2103 reference counter A area 1104, 2104 reference counter B area 1105, 2105, 3104 Work flag area 1106, 2107, 3105 Data area 2106 Work area 3103 Reference count Area

   ─────────────────────────────────────────────────── ─── Continued front page    (72) Inventor Kawamoto ▲ Taku ▼ 2             2-6-1, Sakae, Naka-ku, Nagoya-shi, Aichi             Kawa Building Annex 5th floor Matsushita Electric Information Co., Ltd.             Stem Nagoya Institute F-term (reference) 5B060 AA10

Claims (16)

[Claims] 1. A reference counting means for performing garbage collection by a reference counting method using a referenced counter provided in each memory cell when a reference state to the memory cell is changed by executing the application program, and an application program. Independent counting means for checking the number of actually referenced memory cells for one or more memory cells independently of the execution of A garbage collection device, comprising: setting means for setting a referenced counter. 2. A referenced counter provided in each memory cell, for indicating a referenced number of the memory cell,
The reference count means comprises a predetermined number of bits less than one word, and when the reference state to the memory cell is changed by execution of an application program, the reference count means is a maximum value that the referenced counter of the memory cell can represent by the predetermined number of bits. If the value is smaller, the referenced counter is incremented or decremented to represent the referenced number according to the change, and when the value of the referenced counter becomes 0, the memory cell is released, and the independent count is performed. 2. The garbage collection apparatus according to claim 1, wherein the means performs the check on each memory cell whose referenced counter is at least the maximum value. 3. A check counter of the predetermined number of bits for use in checking by the independent counting means is provided in the memory cell, and the independent counting means is a check counter of the memory cell to be checked. After the initialization processing for setting the value to 0, the investigation counter for each memory cell pointed to directly from the predetermined root pointer or via the pointer chain is actually set within the maximum value that can be represented by the predetermined number of bits. The investigation is performed by performing a counting process that increases so as to indicate the number pointed to by, and the setting unit sets, for each memory cell, the value of the investigation counter of the memory cell in the referenced counter. The garbage collection device according to claim 2. 4. A work flag is provided in the memory cell to indicate whether the investigation state by the independent counting means is the first stage, the second stage or the third stage. Sets the work flags of all the memory cells to the value indicating the first step, then sets the work flags of the memory cells pointed to by the root pointers to the values indicating the second step, and sets the second step. As long as there is a memory cell including the work flag shown, the count process is performed by sequentially focusing on the memory cell and executing the count-up process shown below. A value indicating three stages is set, and when the memory cell includes a pointer to one or more other memory cells, the investigation count for all the other memory cells is set. Is incremented by 1 as long as it does not exceed the maximum value, and the work flag of the other memory cells indicates the first stage, the work flag is set to a value indicating the second stage. When the pointer included in the memory cell including the work flag indicating the third stage is changed by the execution of the application program, the counting means decrements the investigation counter of the memory cell pointed to by the pointer before the change by 1 and The count counter of the memory cell pointed to by the changed pointer is incremented by 1 as long as it does not exceed the maximum value, and the independent count means performs the check in parallel with the execution of the application program, The execution of an application program is suppressed during execution. The placement of garbage collection equipment. 5. A working flag is provided in the memory cell to indicate whether the investigation state by the independent counting means is the first stage or the second stage, and the independent counting means is a memory cell. Using the algorithm of storing the addresses of the above in the stack, set the work flag of all memory cells to the value indicating the first stage, and then stack the addresses of the memory cells pointed to by the root pointer into the stack. The count processing is performed by executing the following count-up processing as long as the memory cell address is loaded in the memory cell, and the count-up processing is performed in the second stage in the work flag of the memory cell indicated by the address taken out from the stack. Is set, and when the memory cell contains a pointer to one or more other memory cells, all other memory cells This is a process of incrementing the check counter for a memory cell by 1 as long as it does not exceed the maximum value, and stacking the address of the other memory cells whose work flag indicates the first stage on the stack. When the pointer included in the memory cell including the work flag indicating the second stage is changed by the execution of the application program, the reference counting means decrements the investigation counter of the memory cell pointed to by the pointer before the change by one. In addition, the investigation counter of the memory cell pointed to by the changed pointer is incremented by 1 as long as it does not exceed the maximum value, and the independent counting means performs the investigation in parallel with the execution of the application program, Suppress execution of application programs during execution of up processing DOO garbage collection apparatus according to claim 3, wherein. 6. The garbage collection device is further provided with a number 0 which is a result of the investigation by the independent counting means.
2. The release means is provided for releasing the memory cell that has become, and the setting means performs the setting only when the number as the investigation result is 1 or more.
Garbage collection device as described. 7. The independent count means is arranged such that each memory cell secured and referred to by the execution of the application program is shorter than an average time from a reference time to a non-reference time, which is shorter than a predicted time. 2. The garbage collection apparatus according to claim 1, wherein the survey is performed, and the setting unit performs the setting each time the independent counting unit surveys. 8. A referenced counter having a predetermined number of bits of less than one word is provided in each memory cell to represent the referenced number of the memory cell, and a reference state to the memory cell is set by executing an application program. If the referenced counter of the memory cell is smaller than the maximum value that can be represented by the predetermined number of bits when changed, the referenced counter is increased or decreased to represent the referenced number according to the change. , When the value of the referenced counter becomes 0, the reference counting method that releases the memory cell is
A reference counting unit that performs garbage collection and an independent counting unit that checks the number of actually referenced memory cells for each memory cell independently of the execution of the application program. After the initialization process of setting the referenced counter to 0, the referenced counter for each memory cell pointed to directly by a predetermined route pointer or through the pointer chain does not exceed the maximum value that can be represented by the predetermined number of bits. In a range, an independent count means for performing a counting process to increase so as to indicate the number actually pointed to, the reference count means, the independent count means, while the investigation is being performed by the independent count means Garbage collection characterized by not releasing memory cells ® down apparatus. 9. The garbage collection device is further provided with a number 0 as a result of the investigation by the independent counting means.
9. The garbage collection device according to claim 8, further comprising a releasing means for releasing the memory cell that has become a memory cell. 10. The predetermined number of bits is a number of bits determined such that a maximum value represented by the predetermined bits is smaller than a value expected to be a peak value of the number of referenced memory cells. Item 2. The garbage collection device according to item 2 or 8. 11. A reference counting step of performing garbage collection by a reference counting method using a referenced counter provided in each memory cell when a reference state to the memory cell is changed by executing an application program, and an application. Independently from the execution of the program, for one or more memory cells, an independent count step of checking the number of actually referenced memory cells, and a number obtained by the independent count step are
And a setting step of setting a referenced counter of a corresponding memory cell. 12. An application program execution environment in which a referenced counter having a predetermined number of bits of less than 1 word is provided in each memory cell that can be reserved and used by an application program and represents the referenced number of the memory cell. A garbage collection method for performing a garbage collection of a memory cell, wherein when the reference state to the memory cell is changed by the execution of the application program, the referenced counter of the memory cell has a value larger than the maximum value that can be represented by the predetermined number of bits. If the value is small, the referenced counter is incremented or decremented so as to represent the referenced number according to the change, and when the value of the referenced counter becomes 0, the memory cell is released by the reference count method. Reference count for garbage collection This is an independent count step of checking the number of actually referenced memory cells for each memory cell independently of the execution of the application program and the step, and sets the referenced counter of the memory cell to be checked to 0. After the initial setting process, the referenced counter for each memory cell pointed directly or through the pointer chain from the predetermined root pointer is actually pointed to within the maximum value that can be represented by the predetermined number of bits. And an independent count step of performing a count process that increases so as to indicate the number of the memory cells, wherein the reference count step releases the memory cell during the investigation by the independent count step. Garbage collection method characterized by avoiding. 13. A control program for causing a computer to perform a garbage collection process, wherein the garbage collection process is provided in each memory cell when a reference state to the memory cell is changed by execution of an application program. The reference count step of performing the garbage collection by the reference count method using the referenced counter and the number of actually referenced memory cells are investigated for one or more memory cells independently of the execution of the application program. Independent counting step, the number that is the result of the survey by the independent counting step,
And a setting step for setting a referenced counter of a corresponding memory cell. 14. An application program execution environment provided with a referenced counter having a predetermined number of bits of less than one word for representing the referenced number of the memory cell in each memory cell that can be reserved and used by the application program. A control program for causing a computer to perform a garbage collection process, wherein the garbage collection process, when a reference state to a memory cell is changed by execution of an application program, a referenced counter of the memory cell is If the value is smaller than the maximum value that can be represented by a predetermined number of bits, the referenced counter is incremented or decremented to represent the referenced number according to the change, and if the referenced counter value becomes 0, the memory cell concerned. By the reference counting method to release the The reference counting step of performing the retraction and the independent counting step of investigating the number of actually referenced memory cells for each memory cell independently of the execution of the application program. A range that does not exceed the maximum value that can be represented by the predetermined number of bits for the referenced counter for each memory cell pointed directly by a predetermined route pointer or through the pointer chain after the initialization processing for setting the reference counter to 0. In the above, the reference counting step includes an independent counting step that performs a counting process that increases so as to indicate the number actually pointed to, and the reference counting step includes the memory during the investigation by the independent counting step. Control characterized by not releasing the cell program. 15. A computer-readable recording medium recording a control program for causing a computer to perform a garbage collection process, wherein in the garbage collection process, a reference state to a memory cell is changed by execution of an application program. In this case, the reference count step of performing the garbage collection by the reference count method using the referenced counter provided in each memory cell, and the execution of the application program independently of one or more memory cells, An independent counting step for investigating the number referred to in
And a setting step for setting a referenced counter of a corresponding memory cell. 16. A function as an application program execution environment, wherein a referenced counter having a predetermined number of bits less than one word is provided in each memory cell that is secured and can be used by an application program to represent the referenced number of the memory cell. A computer-readable recording medium recording a control program for causing a computer to perform a garbage collection process, wherein the garbage collection process, when a reference state to a memory cell is changed by execution of an application program, If the referenced counter of the memory cell is smaller than the maximum value that can be represented by the predetermined number of bits, the referenced counter is incremented or decremented to represent the referenced number according to the change, and the referenced counter is Release the memory cell when the value becomes 0 By the reference count method, a reference counting step for performing garbage collection and an independent counting step for investigating the number of actually referenced memory cells for each memory cell independently of the execution of the application program, After the initialization process of setting the referenced counter of the memory cell to be investigated to 0, the referenced counter for each memory cell pointed to directly by a predetermined root pointer or through the pointer chain is set to the predetermined number of bits. In a range that does not exceed the maximum value that can be represented, including an independent counting step that performs a counting process that increases so as to indicate the number actually pointed, the reference counting step, the reference is performed by the independent counting step. In the middle of A recording medium characterized by being prevented from being released.