CN106293939A - A kind of method of dynamic reuse object in internal memory garbage collector - Google Patents

Abstract

The invention provides a method for dynamically reusing objects in a memory garbage collector, which is used in a Java virtual machine. This method sets the cache space for objects with relatively high reuse value, sets the object cache stack for the corresponding class, and saves the address of the dead object of the corresponding class put by the garbage collector. When allocating reused objects, find the corresponding object cache stack according to the metadata of the class of the reused object. If the object cache stack is not empty, allocate the cached dead object of the same type from the object cache stack. If the object cache stack is empty, start from Objects are allocated in cache space. The present invention records the addresses of dead objects after allocating reused objects, and directly reuses the space of those dead objects when allocating objects of the same type. The invention can reduce the load of the object allocated by the garbage collector, accelerate the object allocation speed, reduce the occurrence times of garbage collection and the management overhead on the memory, and improve the use efficiency of the memory and the overall performance of the virtual machine.

Description

A Method for Dynamically Reusing Objects in Memory Garbage Collector

technical field

The invention belongs to the field of computer application technology, in particular to a method for dynamically reusing objects in a memory garbage collector.

Background technique

At present, many programming languages such as Java, C#, Python, and PHP support garbage collection (GarbageCollectoion, GC), which is used to reclaim useless memory, especially represented by the Java virtual machine. The garbage collector helps programmers to automatically reclaim useless memory, avoiding memory errors that are prone to occur in many traditional programming languages, but the garbage collector needs to occupy the running time of the program to find dead objects and then recycle them, which is very important for frequent allocation. The program of the object is very disadvantageous, and it also increases the memory management overhead (time and space) of the garbage collector, because the program needs to be stopped frequently to reclaim memory.

Contents of the invention

In view of the above problems, the present invention proposes an innovative method for dynamically reusing Java objects, which can efficiently reuse those objects with a large number of allocations and a short life cycle, and avoid garbage collectors from reclaiming these objects, thereby reducing the occurrence of garbage collection The number of times and memory management overhead, improve the efficiency of memory usage and the overall performance of the virtual machine.

A method for dynamically reusing objects in a memory garbage collector provided by the present invention is realized through the following aspects:

(1) Set the organization mode of the cache space; the cache space organizes memory blocks with a linked list. The metadata of the cache space contains two fields: cur_chunk and lock; cur_chunk points to the head node of the linked list, and lock is used to synchronize the access of threads to the same cache space. Memory blocks are used to allocate objects, and the beginning of each memory block stores the metadata of the memory block, including three fields: size, free_ptr, and next_chunk. The field size stores the total size of the memory block, free_ptr is a free pointer, indicating the starting position of the next allocation of objects in this memory block, and next_chunk is a pointer to the next memory block. Memory blocks in the cache space are never freed and are not returned to the operating system until the virtual machine is destroyed.

(2) Set the object cache stack for the selected class with high reuse value, store the pointer to the object cache stack in the metadata of the class, and store the address of the dead object of the corresponding class put into the garbage collector in the object cache stack.

(3) When allocating reused objects, find the corresponding object cache stack according to the metadata of the class of the reused object. If the object cache stack is not empty, allocate the cached dead objects of the same type from the object cache stack. If the object cache stack is Empty, the object is allocated from the cache space.

The advantages and positive effects of the present invention are: the method sets cache space for those objects with relatively high reuse value, and records the addresses of the dead objects after these objects die. When allocating objects of the same type, the space of those dead objects is directly reused. The method can reduce the object allocation load of the garbage collector, accelerate the object allocation speed, reduce the occurrence times of garbage collection and memory management overhead, and improve the memory usage efficiency and the overall performance of the virtual machine.

Description of drawings

Figure 1 is a schematic diagram of the object reference state before garbage collection occurs;

Figure 2 is a schematic diagram of the garbage collector marking the surviving objects;

Fig. 3 is a schematic diagram of the stage of recycling dead objects;

Figure 4 is a schematic diagram after allocating an object of type A;

Fig. 5 is a schematic diagram of the organizational structure of the cache space used by the present invention;

Figure 6 is the metadata of the class and its object cache stack;

Figure 7 shows the normal object allocation process and the optimized allocation process;

FIG. 8 is a process of allocating objects from the cache stack and the cache space respectively.

detailed description

The present invention will be further described in detail with reference to the accompanying drawings and embodiments.

As shown in Figure 1, it is the distribution of objects in the GC (Garbage Collection) heap and cache space. The reference relationship between objects is represented by arrows. The arrow end represents the referenced object. The dotted arrow indicates that the objects at both ends of the arrow are not in the same area, that is, one is in the GC heap and the other is in the cache space. All surviving objects can be reached by the root set. The garbage collector will not reclaim the cache space, and the memory therein will be efficiently used according to the method of the present invention. The organizational structure of the cache space is shown in Figure 5.

As shown in Figure 2, it is the marking phase of the garbage collector. The upper part of the figure is the distribution of objects before marking, and the lower part of the figure is the distribution of objects after marking. All objects that cannot be reached by the root set are marked as dead objects. This stage identifies all surviving objects, and there is no longer any reference relationship between dead objects and surviving objects.

As shown in Figure 3, it is the stage of recycling dead objects. In this stage, if a dead object belongs to the GC heap, it will be processed by the garbage collector according to the normal process; if a dead object belongs to the cache space, the method of the present invention is used to put the object into the object cache stack of the class type to which it belongs , the object cache stack is shown in Figure 6.

As shown in Figure 4, it is the process that occurs when an object of type A is allocated. If the distribution point is an optimized distribution point, the distribution process shown in FIG. 8 will be triggered.

As shown in Figure 5, it is the organizational structure of the cache space. A cache space mainly consists of two parts: one is the metadata required to manage the cache space itself, as shown in the upper left of Figure 5, and the other is one or more memory blocks used to allocate objects, called Chunk. The metadata of the cache space contains two fields, described as follows:

1) cur_chunk, pointing to the current memory block, the cache space organizes multiple memory blocks with a linked list, cur_chunk points to the head node of this linked list, and at the same time, every time an object is allocated, it is always allocated from the current memory block.

2) lock, which is used to synchronize access of multiple threads to the same cache space.

In addition, the initial part of each memory block stores the metadata of the memory block, including three fields, described as follows:

1) size, stores the total size of the memory block, in bytes;

2) free_ptr, the free pointer indicates the starting position when the object is allocated in the memory block next time;

3) next_chunk, a pointer to the next memory block, used to link all memory blocks in the cache space together.

In Figure 5, Chunk A and Chunk B are two memory blocks. Chunk A is the current memory block. A part of the memory at the end of Chunk B is not allocated because the remaining free memory is too small to meet the allocation requirements of the object. Every time an object is allocated from the cache space, memory is always obtained from the current memory block cur_chunk. Memory blocks in the cache space are never freed and are not returned to the operating system until the virtual machine is destroyed.

As shown in Figure 6, it is the relationship between the metadata structure of the class class and the object cache stack. Each class in a Java program has a data structure as shown in Figure 6 inside the virtual machine to represent it, called the metadata of the class, which stores information such as methods, fields, parent classes, interface functions, etc. of this class . Set up an object cache stack for selected classes with high reuse value. In Figure 6, the cache stack pointer cache_stack in the metadata structure of the class points to the object cache stack C_stack, and the object cache stack stores the address of the dead object of type X placed by the garbage collector. The object cache stack can also be implemented with other data structures, such as queues, but the advantage of using the stack is that its last-in-first-out feature means that the allocated objects are always reclaimed recently, which can increase the cache hit rate of the CPU.

As shown in FIG. 7, it is a normal object allocation process and an optimized object allocation process. The upper dotted box part is the normal process of allocating objects, and the lower part of the solid line box is the optimized object allocation process. When allocating objects with high reuse value, special processing needs to be done on the allocation points for allocating these objects. The generated machine code will call the CacheAlloc function to allocate objects. The execution steps of this function are as follows:

Step 1, obtain the pointer cache_stack in the class metadata structure of the object.

Step 2, get the object cache stack C_stack of this type according to the class pointer cache_stack;

Step 3, if the object cache stack C_stack is not empty, perform object allocation according to the process shown by the dotted line on the left side of Figure 8, and allocate the cached dead objects of the same type from the object cache stack C_stack. If the object cache stack C_stack is empty, the object will be allocated from the cache space and go to step 4 for execution.

Step 4, allocate objects from the cache space according to the solid line on the right in Figure 8.

As shown in Figure 8, it shows the process of allocating objects from the object cache stack C_stack and the cache space respectively, which is a continuation of Figure 7. The dotted line on the left is the part where the top element of the stack is fetched from the object cache stack C_stack. Need to go through the following steps:

The first step is to acquire the lock of the object cache stack C_stack;

The second step is to save the top element of the stack to a zero-time variable obj, and then pop the top element of the stack;

obj = C_stack. pop();

The third step is to release the lock of the object cache stack C_stack;

The fourth step is to return obj. obj is the address of the chosen dead object, i.e. the address of the object allocated for reuse.

For example, comparing the changes in Figure 3 to Figure 4, when an object of type A is allocated, since the corresponding object cache stack C_stack is not empty, the top element of the stack can be directly taken, and the memory space occupied by the previous object is reused. At the same time, it avoids interacting with the garbage collector.

The solid line on the right is the following steps to allocate objects from the cache space:

Step 1, acquire the cache space lock;

Step 2, if the free memory of the current memory block in the cache space satisfies the size of the object, first assign the free_ptr value of the current memory block to the temporary variable obj, and then let free_ptr increase the size of the object obj_size; if the free memory of the current memory block is smaller than the object size, go to step 5;

Step 3, release the cache space lock;

Step 4, return obj, obj is the address of the allocated reused object;

Step 5, apply for a new memory block from the operating system, use this memory block as the current memory block, update the values of cur_chunk and free_ptr, and go to step 2.

The innovation of the present invention mainly lies in that a cache space is set, dead objects are reused, and the selected objects with high reuse value are optimally allocated by the above-mentioned method of the present invention. Objects with high reuse value refer to some objects that are allocated in large numbers and die in large numbers in the program.

Claims (4)

1. the method for dynamic reuse object in internal memory garbage collector, it is characterised in that realized by following aspect:

(1) organizational form of spatial cache is set；Memory block is organized by spatial cache with a chained list.The unit of spatial cache Packet contains two field: cur_chunk and lock；Cur_chunk points to the head node of chained list, and lock is used for synchronizing thread pair The access of same spatial cache；Memory block is used for distribution object, and the start-up portion of each memory block deposits first number of memory block According to, comprise three fields: size, free_ptr and next_chunk；Total size of stored memory block, free_ in field size Ptr is free pointer, represents original position during distribution object in this memory block next time, and next_chunk is for pointing to next The pointer of individual memory block；Memory block in spatial cache never discharges, until just returning to operating system when virtual machine is destroyed；

(2) the costly class of reusing for selecting all arranges target cache stack, deposits sensing target cache in the metadata of class The pointer of stack, preserves the address of the dead object of the corresponding class that garbage collector is put in target cache stack；

(3) when object is reused in distribution, the target cache stack of correspondence is found according to the metadata of the class reusing object, if object delays Deposit stack not for empty, from target cache stack, distribute the same type death object of caching, if target cache stack is empty, from spatial cache Middle distribution object.

A kind of method of dynamic reuse object in internal memory garbage collector the most according to claim 1, it is characterised in that The described same type death object distributing caching from target cache stack, specifically:

The first step, obtains the lock of target cache stack；

Second step, preserves stack top element to zero variations per hour obj, then ejects stack top element；

3rd step, the lock of releasing object caching stack；

4th step, returning obj, obj is the address that object is reused in distribution.

A kind of method of dynamic reuse object in internal memory garbage collector the most according to claim 1, it is characterised in that Described distribution object from spatial cache, specifically:

1st step, obtains the lock of spatial cache；

2nd step, if the free memory of current memory block meets object size in spatial cache, the most first by current memory block Free_ptr value gives temporary variable obj, then allows free_ptr increase the size of object；If the free memory of current memory block Less than object size, then forward the 5th step to；

3rd step, release spatial cache lock；

4th step, returning obj, obj is the address that object is reused in distribution；

5th step, to one new memory block of operating system application, using this memory block as current memory block, and updates cur_ The value of chunk and free_ptr, forwards the 2nd step to and performs.

A kind of method of dynamic reuse object in internal memory garbage collector the most according to claim 1, it is characterised in that Described target cache stack, it is also possible to replace with queue, to preserve the dead object of the corresponding class that garbage collector is put into Address.