JP2526384B2 - Garbage collection method - Google Patents

Description

Description: TECHNICAL FIELD The present invention relates to a garbage collection system for packing garbage data dynamically generated during execution of a program in a computer into one end of an actual memory.

[Conventional technology]

Numerical calculations have been the mainstream of conventional computer applications.
In recent years, so-called symbol processing, which directly handles human knowledge, has been attracting attention. In symbol processing, significant data in the main memory (real memory) is pointed to by the data containing the address of the main memory called a pointer, and the necessary data is indicated. The process of connecting with a pointer occurs frequently.

The process of connecting with the pointer is performed as needed during the execution of the program, and the pointers are changed. Data that is no longer referenced due to pointer relocation is never referenced during subsequent program execution. Such data is called garbage. Since garbage data is generated during program execution and scattered in the main memory, the process of detecting it and regenerating a new pointer generation area in the main memory, that is, the garbage collection function is required for symbol processing. .

In the garbage collection of the mark & sliding compaction method, first, the main memory cells holding the data necessary for program execution are marked (called marking). Next, in sliding compaction, marked cells are sequentially packed from one end of the main memory.

The sliding compaction algorithm is CO
Morris' method published in MM OF THE ACM, 21, 8, 1978 (PP662-665) is famous. This is because the garbage collection target area is packed, and the necessary pointer value change (called pointer maintenance) is performed by using the reverse pointer instead of using a special work area, and the target area is changed twice. This is a method performed by sweeping.

7 to 10 are decoding diagrams of the sliding compaction known as the Morris algorithm described above. In FIG. 7, 1 is a sweep pointer for sweeping one cell of the real memory corresponding to an independent logical space for each process which is an execution unit of a program, and 2 is an upward pointer 4 for referencing the cell 3 The cell 5 that is present is a reverse pointer that references cell 3 to cell 2. In FIG. 8, reference numeral 6 corresponds to the upward pointer 4 obtained by processing the reverse pointer 5, and shows the moving destination of the cell 3 after garbage collection. In FIG. 9, 7 is a location pointer for assembling cells that are not unnecessary areas (garbage) from one end of the logical space, 8 is a downward pointer referencing the cell 11, and 12 is generated when the pointer 8 is processed. The reverse pointer. In FIG. 10, 13 is a reverse pointer 12
Is a pointer after garbage collection corresponding to the pointer 8 obtained by processing

Next, the compaction operation by the Morris method will be described. The compaction is performed by sweeping the logical space targeted for garbage collection by two passes, that is, two sweeps. At this time, as a prerequisite, the total number of garbage cells in the target area is known,
Cells that are not garbage need to be marked. Marking must be done to meet these conditions.

7 and 8 show the processing of the first pass of the compaction phase. The sweep of the first pass is performed in the same direction as the assembling. Main memory sweep pointer 1
Sweeps from cell 2 to cell 3. Also, in the figure, the logical address of cell 2 is larger than the logical address of cell 3. In the processing of the first pass, only the upward pointer (a pointer that refers to a cell whose logical address is smaller than the cell in which the pointer is written) and the reverse pointer are subject to processing.

FIG. 7 shows the processing when the sweep pointer 1 detects the upward pointer 4. In this case, the reverse pointer 5 to cell 2 is written in cell 3, and the contents of cell 3 are copied to cell 2.

FIG. 8 shows the processing when the sweep pointer 1 detects the reverse pointer 5. For the cell 2 referred to by the reverse pointer 5, the move destination address of the cell 3 after the garbage collection is calculated, and the pointer 6 to the move destination cell 4 ′ of the cell 3 is calculated.
write. Also, the contents of cell 2 are copied to cell 3. The destination address after this garbage collection is obtained as follows. Each time the sweep pointer 1 detects a cell in an unnecessary area, it reduces the number of unnecessary area cells in the compaction target area that was known at the start of compaction. By doing so, the sweep pointer 1 can calculate the destination logical address after the garbage collection of the cell currently being swept, from the logical address currently swept and the number of unnecessary area cells existing in the unswept area. It is possible.

9 and 10 show the processing when the sweep pointer 1 detects a cell in which the pointer is written in the second-pass logical space sweep. At this time, assembling of cells in the actual logical space, processing of the downward pointer, and processing of the reverse pointer generated during the processing of the downward pointer are performed. The location pointer 7 first presses the cell 9 having the smallest logical address. If the sweep pointer 1 detects a cell 10 that is not an unnecessary area and the content of the cell 10 is not a pointer, the content of the point destination cell of the sweep pointer 1 is copied to the point destination cell of the location pointer 7 and the value of the location pointer 7 is copied. Increase by 1.

In FIG. 9, the sweep pointer 1 detects the cell 10 in which the downward pointer 8 is written. Cell at this time
Contents of 10 and cell 11 referred to by the downward pointer 8
A pointer 12 to the cell 9 which the location pointer 7 refers to is written in. In the example shown in FIG. 9, X is written in the cell 9 referred to by the location pointer 7.
This is the case where X is not a pointer, and to be precise, the contents of the cell 10 referred to by the sweep pointer 1 are considered to be X, and the processing is continued.

In FIG. 10, the sweep pointer 1 detects the cell 11 in which the reverse pointer 12 is written. At this time, the reverse pointer
A pointer 13 to a cell 14 referred to by the location pointer 7 is written in the cell 9 referred to by 12.

In this way, the relationship between the cell 9 and the cell 11 shown on the left side of FIG. Also, as shown in FIG. 10, in the processing of the second pass, the sweep pointer 1
Is detected, the value of the upward pointer 12 has already been maintained at the value after garbage collection in the processing of the first pass, so the content of the cell 11 referred to by the sweep pointer 1 is referred to by the location pointer 7. Copy it to cell 14

[Problems to be Solved by the Invention]

By the way, in the conventional garbage collection method, that is, in the mark & sliding compaction method algorithm, the direction of the pointer written in each cell is determined by the logical address of the cell and the content of the cell as described above. In order to perform the operation of rewriting the content of the related cell according to the orientation, it is essential that the correspondence between the logical address and the physical address (real memory address) is one-to-one.

However, when the physical space (real memory) corresponding to a part of the logical space given for each process is shared by all processes, a situation as shown in FIG. 11 may occur. That is, the logical space of the process i is mapped to the physical space 17 and the physical space 15 shared by all processes, and the logical space of the process j is mapped to the physical space 16 and the physical space 15. At this time, both the cell 18 and the cell 19 refer to the cell 20 in the shared area. In such a case, the above-mentioned conventional garbage collection method can target only one type of logical space. Therefore, when the garbage collection of the process i is performed as shown in FIG. 11, the cell 19 refers to it. I don't know the destination address of cell 20. Therefore, in the conventional garbage collection method, when a plurality of cells refer to the same cell as shown in FIG. 11, each cell is associated with a pointer, for example, the cell 18 and the cell 19 are logical. Since the space is different, it is not possible to set a pointer, which makes sliding compaction impossible.

The present invention has been made to solve the above problems, and is used by all processes on a system in which a logical space independent for each process and a logical space shared between processes are provided. It realizes the garbage collection function for the existing logical space by marking and sliding compaction.

[Means for solving the problem]

The garbage collection method according to the present invention provides a logical space independent for each process, which is a program execution unit, on a computer system having a multiple logical space such that a part of this logical space is shared between the processes. Is a method of performing a garbage collection in a sliding method for all cells in the process including the shared logical space, which is not subject to garbage collection in the process shared area corresponding to the shared logical space shared by all processes. In this area, a work area with a size proportional to the total number of cells in the shared logical space referenced by each process is provided, and the contents of the cells in the process shared area are assigned to the actual memory cells that make up this work area. Move and store the data indicating the move in the cell of the process sharing area, and Marking is performed by changing the pointer so that the cells in the area refer to the actual memory cells in the work area, and then the work area and the process sharing area are made continuous areas to perform compaction by the sliding method. It is characterized by.

[Action]

The work area 21 is created as an intermediate table from the logical space unique to each process to the shared logical space when the actual memory cells 29, 30, 31 are marked. Therefore, when the compaction of the shared area is performed after the marking is completed, the transfer destination address of the cell referred to in the shared area 20 is stored in the intermediate table created in the work area 21.

Example of Invention

FIG. 1 is an explanatory diagram of the operation before the garbage collection is performed by the garbage collection method according to the embodiment of the present invention, the marking is completed, and the shared area is compacted. In the figure, 22 is an example of the state of the main memory (real memory) before execution of garbage collection, 16 and 17 are physical space real memory areas, 18, 27, 19 and 28 are cells, and 20 is shared among all processes. An area 21, a work area for garbage collection taken in an area of the shared area that is not subject to garbage collection, and 23, 24, 25, 26 are pointers. 39 is an example of the state of the main memory at the end of marking, 27,2
8, 29, 30, 31 indicate cells, and 32, 33, 34, 35, 36, 37, 38 indicate pointers. Also, 43 is an example of the state of the main memory at the end of compaction of the shared area, and 40, 41, 42 are movements at the end of garbage collection of cells in the shared area that were referenced by other cells written in the work area 21. This is a pointer indicating the destination address.

FIG. 2 shows the data type and the structure of one word handled in one embodiment according to the present invention. In the figure, 44 is a gc bit (2 bits) as a flag for the garbage collector to know the meaning (cell state) of each cell, and 45 is a tag part indicating the data attribute of the value part 46. Vect, cds as the data type
There is c, INT. vect is a pointer to an area continuously taken in the shared area, and the data at the pointer destination is cdsc (descriptor). In the value part of cdsc, the size of the continuous area is written. INT indicates that the value part is an integer. The continuous area in the shared area pointed to by vect is called a vect body. Also, vect only in the shared area
body is taken. INT and vect are allowed as data types appearing in the vect body.

It should be noted that the vect does not have a nest inside the vect body as shown in FIG. The structure created on the shared area is a tree structure. The gc bits are all 0 before the garbage collection is started, and the gc bits of the cells required after the garbage collection are set to one of the three states of mk, en and rev. mk means that the marking of the cell has already been completed, and there is no cell referencing the cell. en means that there is a cell that refers to the cell. rev is a pointer generated at the time of compaction, and indicates that the content of the cell is a reverse pointer.

At the time of marking garbage collection, the gc bit is sequentially set in the cell in which the data necessary for program execution is written among the data written in the process specific area. At this time, when the pointer vect to the shared area is detected (hereinafter, this pointer is called a root pointer), the gc bit of the cell in the shared area that can be traced from the vect is set.

FIG. 4 is a flowchart showing the marking procedure starting from the root pointer. The cell pointed to by the route pointer is read (step S1), the gc bit is determined (step S2), and if the gc bit is in the en state, the route process I
Is executed (step S3). Process I of this route
Shown in the figure. Shared area from cell 50 in process-specific area 17
References cell 51 in 20. The gc bit of cell 51 is already en and the content of cell 51 is already a pointer to work area 21. In this case, the contents of cell 51 are copied to cell 50.

Also, in step S2, the gc bit is un (mk, en, rev
If it is determined that the state does not belong to any of the above), the process II of the route in step S4 is executed. Processing II of this route is shown in FIG. The cell 53 in the process-specific area 17 is referred to the cell 54 in the shared area 20. The gc bit of cell 54 is un. The contents of the cell 54 are copied to the unused cell 55 of the work area 21, and the gc bit is set to mk. After that, the logical address of the cell 55 is written in the value part of the cell 54. In this way, the main body of vect is marked (step S6) until the processing trace of the route pointer and the end judgment (step S7) are made. By marking in this way, the state of 39 shown in FIG. 1 is reached at the end of marking.

Next, the compaction process will be described. Basically, it is the same as the Morris method described above, but the following points are different. When the shared area 20 is packed to the smaller logical address, the logical address of the work area 21 is treated as being smaller than the logical address of the shared area 20. Shared area 20,
The work area 21 is a continuous area and is a target area for compaction. In the sweep of the first pass of compaction, the processing when a cell whose gc bit is en is detected is added to Morris' method. The total number of cells that are not unnecessary areas is
This is the sum of the total number of cells that are not unnecessary areas in the shared area 20 and the used work area 21. When the en cell is detected, the cell content of the work area 21 referred to by the en cell is processed as if it was written in the en cell. At this time, the logical address of the en cell is written in the cell of the work area 21 that was referenced by the en cell. The sweep of the first pass is performed up to the shared area 20. Next, the processing of the second pass is performed from the work area 21 in the same procedure as Morris' method. The work area 21 is secured word by word at a timing when one pointer to the shared area 20 is generated during normal program execution.

Although the data structure permitted on the shared area 20 is limited to the tree structure in the above-described embodiment, the same effect can be obtained even when the data structure is not a tree structure by changing the processing of the root pointer.

According to the above embodiment, the work area for the garbage collector is set in the area shared between the program execution units (processes), and this work area is used to create a cell corresponding to the logical space unique to each program execution unit. The maintenance of the pointer from the to the shared logical space enables the compaction, which was impossible with the conventional compaction algorithm.

〔The invention's effect〕

As described above, according to the present invention, the work area for the garbage collector is set in the area on the real memory shared by the processes, and this work area is used to identify the process-specific logical space corresponding to the process-specific logical space. Compaction is performed as a continuous area in the process shared area corresponding to the area and the shared logical space shared by all processes, so an independent logical space for each process and a logical shared between processes Space-giving and garbage collection functions for the logical space used by all processes on the system can be realized by marking-and-sliding compaction, and thus multiple logical logics that cannot be operated by the conventional sliding compaction algorithm. Garbage collection for space becomes possible, The effect is obtained that the re-use of real memory is possible good.

[Brief description of drawings]

FIG. 1 is a diagram for explaining the operation before the garbage collection is executed by the garbage collection method according to the embodiment of the present invention, the end of marking, and the operation after the compaction of the shared area, and FIGS. 2 and 3 are the embodiments. In FIG. 4, the data structure allowed in the shared area, FIGS. 4 to 6 are explanatory diagrams of marking in this embodiment, and FIGS. 7 to 10 are explanatory diagrams of compaction known as a conventional Morris algorithm. FIG. 11 is a diagram for explaining the problems of this Morris algorithm. 16,17 …… Physical space (process-specific area), 18,19,27,2
8,29,30,31 …… Real memory cell, 20 …… Shared area, 21 ……
Work area.

Claims (1)

(57) [Claims] 1. A shared logic is provided on a computer system having a multiple logical space in which an independent logical space is provided for each process which is an execution unit of a program, and a part of this logical space is shared by each process. A method of performing a garbage collection in a sliding method for all cells in a space-combined process, in the area not subject to garbage collection in the process shared area corresponding to the shared logical space shared among all processes, A work area with a size proportional to the total number of cells in the shared logical space referenced by each process is provided, and the contents of the process shared area cells are moved to the actual memory cells that make up this work area. Data indicating the movement is stored in the shared area cell, and the work area is stored in the process specific area cell. Performs a marked make changes of the pointer to reference the actual memory cell of,
Then, a compaction method using a sliding method is performed, in which a work area and a process sharing area are contiguous to each other and compaction is performed.