KR100753821B1 - Garbage collection apparatus and method - Google Patents

Abstract

Disclosed are a garbage collection apparatus and an method thereof in an embedded environment. The memory is divided into a young generation area consisting of the first area and a second area and an old generation area consisting of a predetermined number of blocks, and the copying garbage for the first area and the second area by dividing the area in half for the young generation. The collection is alternately performed, and the aged generation area is gradually garbage collected in units of frames including a predetermined number of blocks. This minimizes the time delay of garbage collection to ensure real time.

Description

Garbage collection apparatus and method

1 illustrates an embodiment of a system for performing memory management and garbage collection through a Java virtual machine;

2 is a diagram illustrating an embodiment of a method of operating a generation garbage collector;

3 is a view showing the configuration of an embodiment of a garbage collection device according to the present invention;

4 is a diagram illustrating an embodiment of a heap structure of a memory according to the present invention;

5 is a view showing the structure of the old generation of the heap structure of FIG.

6 is a view illustrating a garbage collection performed for each frame according to the present invention;

7 is a diagram showing an embodiment of a write protection processing method using a primary filter according to the present invention;

8 is a view showing an embodiment of a write protection processing method using a secondary filter according to the present invention;

9 is a flowchart illustrating a flow of an embodiment of a garbage collection method according to the present invention;

10 is a flowchart illustrating a garbage collection method in a heap of a young generation according to the present invention, and

11 is a flowchart illustrating a garbage collection method in an old generation heap according to the present invention.

The present invention relates to a garbage collection apparatus and a method thereof, and more particularly, to a garbage collection apparatus and method for ensuring a real-time by reducing the delay time by the garbage collection in the embedded environment.

J2ME is a Java technology for embedded environment. It is used in networked embedded or mobile devices such as smart phones, handheld devices, PDAs, screen phones, set-top boxes, and net TVs. It is divided into Limited Device Configuration (CDC) and Connected Device Configuration (CDC) platforms.

The CLDC platform is used on targets with extremely limited memory or CPU capabilities, such as mobile phones and PDAs, and the CDC platform is mainly used in embedded systems with more extended resources and capabilities such as home networks, telematics and set-top boxes.

The Garbage Collector typically uses the Reference Counting Garbage Collector to mark objects as reachable from the rootset, and reclaims them all at once (Mark & Sweep). Use a semi-space copying collector to copy the surviving object to another.

In Java, dynamic memory allocation or garbage collection has a critical impact on device performance. Especially in the embedded environment, there are various problems. First, most embedded devices have a small memory capacity. Second, power consumption is an important optimization parameter in battery-operated systems. Third, the Java virtual machine in the embedded environment is not as good as the general system supported by many native classes. As the embedded Java virtual machine is designed to run for a long time in an embedded system with limited memory, it is important to create and manage Java objects.

It is an object of the present invention to provide a garbage collection device and a method for minimizing time delay caused by garbage collection in an embedded environment and using a memory as efficiently as possible.

According to one embodiment of the garbage collection apparatus according to the present invention, the memory is divided into a young generation area consisting of a first area and a second area and an old generation area consisting of a predetermined number of blocks. A memory manager; And a garbage collector configured to alternate garbage collection for the first and second regions for the young generation, and to perform garbage collection on a frame-by-frame basis for the old generation region. Include.

In order to achieve the above technical problem, an embodiment of the garbage collection method according to the present invention includes (a) a young generation area including a first area and a second area, and an old generation consisting of a predetermined number of blocks. Dividing into regions; And (b) alternately performing garbage collection on the first and second regions for the young generation, and performing garbage collection on a frame basis including a predetermined number of blocks for the old generation region. It includes.

Hereinafter, a garbage collection apparatus and a method thereof according to the present invention will be described in detail with reference to the accompanying drawings.

1 is a diagram illustrating an embodiment of a system for performing memory management and garbage collection through a Java virtual machine.

When the Java virtual machine 100 receives a memory allocation request from a Java program, the memory manager 110 allocates the required memory 130 from the heap managed by the Java program to the application and hands it over to an application program. If not, run the garbage collector 120 to secure the necessary memory. The memory manager 110 and the garbage collector 120 cannot be separated separately, and the memory manager 110 depends on the garbage collector 120 according to the technique of the garbage collector 120.

2 is a diagram illustrating an embodiment of a method of operating a generation garbage collector.

The generation-based garbage collector shown in FIG. 2 is assigned a new object in the young generation. If there is no free space in the young generation, start the collector of the young generation, and secure memory space by copying objects surviving the young generation to the mature space after the collector startup. If a situation arises in which the mature space is full and the surviving object cannot be copied, run the old generation garbage collector.

3 is a diagram illustrating a configuration of an embodiment of a garbage collection apparatus according to the present invention.

Referring to FIG. 3, the garbage collection apparatus includes a memory 300, a memory manager 310, and a garbage collector 320.

The memory manager 310 divides the memory heap into a young generation area and an old generation area. In addition, the memory manager 310 divides the young generation area into two parts and the old generation area into a predetermined number of blocks.

The garbage collector 320 applies the semi-space copy collector 322 to the young generation area and the copy collector 324 to the old generation area.

The semispace copy collector 322 alternately performs garbage collection for two areas of the young generation area, that is, the first area and the second area, and when the garbage collection is performed for the first area, the surviving object is stored in the second area. If garbage collection is performed for the second region, the surviving object is copied to the first region.

The copy collector 324 in the old generation performs garbage collection in a frame unit composed of a predetermined number of blocks of the old generation area, and then copies the surviving object into a frame (reserved frame) in which the previous garbage collection was performed.

Each block of the old generation region includes a reference bitmap that indicates whether or not the objects in each block are referenced by other objects, and the garbage collector is based on the reference bitmap. Objects not referenced from an object are tracked and determined to be garbage. Garbage determination and tracking using the reference bitmap will be described in detail with reference to FIGS. 7 and 8.

4 is a diagram illustrating an embodiment of a heap structure of a memory according to the present invention.

Referring to FIG. 4, the heap 400 is divided into a young generation area 410 and an old generation area 420. Since the area 410 of the young generation is smaller than the area 420 of the old generation, the time delay caused by garbage collection is small enough to satisfy the real-time.

The young generation area 410 is divided into spaces fromSpace 430 and toSpace 440. fromSpace 430 is an area for garbage collection, and toSpace 440 is an area for surviving objects to be copied.

When you move an object to another area, you must move its children as well. Each object is colored to distinguish whether it has been moved to each child object. For example, white means that the object has not been explored yet, gray means that the object has been explored but not all of its child objects, and black means that all of the child objects have been explored and copied completely. do.

FIG. 5 is a diagram illustrating an old generation structure of the heap structure of FIG. 4.

Referring to FIG. 5, the old generation heap is divided into block units 502, 504, 512, 514, 522, 524, 532, and 534 and garbage collection is performed in units of frames 500, 510, 420, and 530. Specifically, the old generation area is divided into equally sized blocks and these blocks are connected by a double linked list. Each block is the smallest unit of object allocation and garbage collection. A frame is formed by grouping several blocks together to form a frame, which becomes the target frame of garbage collection in frame order.

One frame of the frame is additionally reserved and used as a space where objects are copied when the collection is performed. Frames selected for garbage collection are frames with a long allocation of objects. Frames with outdated object allocations are subject to garbage collection because they are not garbage collected at the beginning of their creation, and the surviving objects are generations that have long-lasting arguments, thus providing enough garbage recovery time for these objects to die. To increase.

6 is a diagram illustrating garbage collection performed for each frame according to the present invention.

When running once, the garbage collector performs garbage collection only on specific target frames, not the entire heap, and then moves to the next target frame. The garbage collector performs a first garbage collection on the first frame 600, and then performs a second garbage collection on the second frame 610. As described above, the garbage collector sequentially performs garbage collection on the third frame 620 and the fourth frame 630, respectively.

There is a reservation frame 640 in the old generation heap, in which objects that survive after garbage collection are copied. After garbage collection is performed for a given frame, the frame on which garbage collection is performed becomes the reserved frame 640. Blocks having empty space in the reserved frame 640 are divided into free space and used as a space for copying a new object.

Whether an object is garbage or not can be determined by whether the object from the root set is reachable. However, an object referenced by another object, even if it is not reachable from the root set, should not be considered garbage.

To prevent objects referenced from other objects from becoming garbage, all objects on the heap must be tracked for references from other objects. However, the conventional method is time consuming and is not suitable in an embedded environment requiring real time.

7 is a diagram illustrating an embodiment of a write protection processing method using a primary filter according to the present invention.

The problem that an object referenced from another object becomes garbage (that is, a write barrier problem) arises in two situations. The first case refers to an object in the young generation from the old generation, and that object is the object of garbage collection. In the second case, an object in the frame that is garbage collected when garbage collection is performed in the old generation. This is the case when is referenced in a block of another frame.

Referring to FIG. 7, it is the first case that the object A 712 of the predetermined block 710 of the old generation refers to the object C 702 of the young generation 702, and the predetermined block 710 of the old generation. This is the second case in which object B 714 of) refers to object D 742 of another block 740.

The header of each block 710, 720, 730, 740 of the heap includes a reference bitmap 750, and the reference bitmap 750 indicates whether there is an object referenced from another generation or another block of the same generation in the corresponding block. For example, in the reference bitmap 750, 1 means that there is an object referenced and 0 means that no object is referenced. Therefore, the reference bitmap can be used to filter the number of blocks to be traced.

Although the blocks to be tracked are determined by the primary filter using the reference bitmap 750, a large number of objects may exist in one block, and tracking all of these objects also takes considerable time. Therefore, it is necessary to use a second order filter.

8 is a diagram illustrating an embodiment of a write protection processing method using a secondary filter according to the present invention.

After dividing each block 800 logically into units of pages 810, the reference state is stored for each page, and the object tracking can be changed according to the stored reference state.

Referring to FIG. 8, reference state information of each page is one of CLEAN, DIRTY, and SUMMARIZE. The CLEAN state means that there are no references to other blocks on the page, the DIRTY state means that there are at least five objects referenced by other blocks on the page, and the SUMMARIZE state means that the number of objects referenced by other blocks on the page It means four or less.

If the reference status is CLEAN, the page does not need to be tracked. If it is DIRTY, all objects in the page should be tracked. If it is SUMMARIZE, the address of the referenced object is stored in a separate summary table 820 so that the objects can be retrieved quickly. . The summary table 820 can be used to quickly and easily obtain an address for an object referencing an object in another block.

9 is a flow chart showing the flow of one embodiment of a garbage collection method according to the present invention.

Referring to FIG. 9, a memory heap is first divided into a young generation area consisting of two areas and an old generation area consisting of a predetermined number of blocks (S900). The garbage collector performs a semi-space copy collection on the young generation area in the divided memory, and performs a copy collection on a frame basis composed of a predetermined number of blocks on the old generation area (S910). Hereinafter, a garbage collection method will be described in detail with reference to FIGS. 10 and 11.

10 is a flowchart illustrating a garbage collection method in a heap of a young generation according to the present invention.

Referring to FIG. 10, the garbage collector first checks the root set including the stack (S1000). The garbage collector verifies that objects in the fromSpace space of the young generation heap are reachable from the root set. Objects that are not reachable from the root set are determined to be garbage and are immediately recovered and the objects that survived without being recovered are copied to toSpace (S1005).

Since the object copied to toSpace has not been searched until all the child objects, the object is painted in gray as described with reference to FIG. 3 (S1010). It is determined whether all objects are searched for the object painted in gray (S1015). If all of the child objects are not searched, the purple objects are included in the root set (S1020). If all the objects have been searched for, the object is painted black to indicate that all of the objects have been searched (S1025).

If the search of all root sets is completed (S1030), the roles of fromSpace and toSpace are interchanged (S1035). Therefore, the next garbage collection is performed in toSpace, and the surviving object is copied to fromSpace, and then the roles of the two are reversed.

11 is a flowchart illustrating a garbage collection method in an old generation heap according to the present invention.

Referring to FIG. 11, the garbage collector first selects a target frame of garbage collection (S1100). The target frames of the garbage collection are sequential in frame order, as noted above. The objects reachable from the root set among the objects existing in the block of the target frame are copied to the reserved frame (S1110). When the copy is completed, the age of the blocks is readjusted (S920) and the corresponding frame is emptied (S1130).

The invention can also be embodied as computer readable code on a computer readable recording medium. The computer-readable recording medium includes all kinds of recording devices in which data that can be read by a computer system is stored. Examples of computer-readable recording media include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical data storage, and the like, and may also be implemented in the form of a carrier wave (for example, transmission over the Internet). Include. The computer readable recording medium can also be distributed over network coupled computer systems so that the computer readable code is stored and executed in a distributed fashion.

So far I looked at the center of the preferred embodiment for the present invention. Those skilled in the art will appreciate that the present invention can be implemented in a modified form without departing from the essential features of the present invention. Therefore, the disclosed embodiments should be considered in descriptive sense only and not for purposes of limitation. The scope of the present invention is shown in the claims rather than the foregoing description, and all differences within the scope will be construed as being included in the present invention.

The garbage collector according to the present invention is suitable for an embedded environment that requires real-time because it minimizes the delay time caused by garbage collection. In addition, it is possible to use the memory as efficiently as possible in the memory-limited embedded environment, and it is installed in the Java virtual machine for running Java applications so that Java applications can be quickly run on various embedded devices.

Claims (17)

delete delete delete delete A memory manager for dividing the memory into a young generation area consisting of a first area and a second area and an old generation area consisting of a predetermined number of blocks; And A garbage collector configured to alternate garbage collection with respect to the first area and the second area for the young generation, and to perform garbage collection on a frame-by-frame basis with a predetermined number of blocks for the old generation area. and The garbage collector is an object that is reachable from the root set, an object that is reachable from the root set, an object reachable from the root set but not searched to a child object, an object reachable from the root set but searched to a child object. Separated by,  The garbage collector is a garbage collection device, characterized in that to color-code the objects of the young generation area delete delete delete delete A memory manager for dividing the memory into a young generation area comprising a first area and a second area and an old generation area consisting of a predetermined number of blocks; And And a garbage collector configured to alternate garbage collection with respect to the first and second regions for the young generation, and to perform garbage collection on a frame-by-frame basis with a predetermined number of blocks for the old generation region. and,  The garbage collector divides each block of the old generation area into predetermined page units, and includes a reference bitmap indicating whether reference is made by another object for each page unit. The garbage collector, based on the reference bitmap, the garbage collection device to determine the garbage by tracking an object not referenced from another object among the objects that are not reachable from the root set The garbage collection apparatus of claim 10, wherein the reference bitmap indicates a state in which a predetermined page is not referenced from another object, or a state in which a predetermined page is referenced from a predetermined number or more or less. delete delete delete delete delete (a) dividing the memory into a young generation area consisting of a first area and a second area and an old generation area consisting of a predetermined number of blocks; And (b) alternately performing garbage collection on the first area and the second area for the young generation, and performing garbage collection on a frame basis including a predetermined number of blocks for the old generation area; Including In step (b), each block of the old generation area is divided into predetermined page units, and among the objects that are not reachable from the root set based on a reference bitmap indicating whether or not a reference is made by another object for each page unit. Determining a garbage by tracking an object not referenced from another object;

Images