JP2004078636A - Memory management system, memory arranging method and its program and recording medium - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To improve the hit rates of data cache and TLB cache by collecting objects frequently referred to from one thread as a data taken into a data cache and TLB at the time of process execution. <P>SOLUTION: By providing a memory control part 10 dynamically controlling an arrangement destination of a memory of an object generated by a plurality of threads in the processes execution in a computer (calculator) and arranging frequently-used objects nearby, and assigning a unique area for every thread in a heap area of a logical memory space in the process, the object generated by one thread is continuously arranged on a memory or a memory device. <P>COPYRIGHT: (C)2004,JPO

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a technique for dynamically allocating objects generated when a process is executed in a computer, and more particularly to a memory management technique suitable for improving cache performance and the like.
[0002]
[Prior art]
In a normal computer (computer), the execution unit of a process is a thread, and individual objects generated by the individual threads when the process is executed are stored in the heap area for the process in the order of generation, and thereafter, the thread unit When the process is executed by the CPU, the central processing unit (CPU) reads the above-mentioned object from the heap area and executes it.
[0003]
At this time, conventionally, frequently used objects are stored in a data cache having an access speed higher than that of a heap area, thereby increasing the execution speed.
[0004]
However, in general, the size of the data cache is finite, the size of the data taken into the data cache is fixed, and basically, the data taken into the data cache is a partial copy of the memory used by the process. And is also a partial copy of the heap area. Therefore, even in the data cache, the objects are held in the order of generation.
[0005]
As described above, the data cache does not hold all the objects generated by each thread of one process. Therefore, all objects in the data read from the data cache by the central processing unit are not necessarily objects frequently used in one thread, and a cache miss occurs.
[0006]
In general, the logical memory space used by one process is effective only within that process, and generally, the logical memory space used for each process is switched. Memory space mapping is required.
[0007]
A buffer for temporarily storing frequently used ones in a correspondence table from an address (virtual address) of a logical memory space visible to a process to an actual memory address (physical address) is provided in a TLB (Translation Look-Aside Buffer). ), The use of this TLB enables high-speed conversion between these virtual addresses and physical addresses.
[0008]
However, the above-described logical memory space includes the above-described heap area, and if objects are arranged on the heap area in the order of generation, all of the objects included in one conversion stored in the TLB are one thread. Is not always referred to.
[0009]
[Problems to be solved by the invention]
The problem to be solved is that in the related art, not all objects included in the data cache and TLB are frequently used by one thread.
[0010]
SUMMARY OF THE INVENTION An object of the present invention is to solve the problems of the prior art, and to collect data frequently fetched from one thread into a data fetched into a data cache and a TLB at the time of executing a process, that is, a heap area. And to improve the hit rate of the TLB cache.
[0011]
[Means for Solving the Problems]
In order to achieve the above object, the present invention is characterized in that a memory allocation destination of an object generated by a plurality of threads when a process is executed in a computer is dynamically controlled, and frequently used objects are arranged near each other. That is, by allocating a unique area for each thread to a heap area of a logical memory space in a process, objects generated by one thread are continuously arranged on a memory or a storage device. As a result, the objects generated in the heap area are grouped in units of threads, and the possibility that an object of the same thread is included in a plurality of objects in the unit data taken into the data cache is increased. Hit rate is improved.
[0012]
BEST MODE FOR CARRYING OUT THE INVENTION
Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.
[0013]
FIG. 1 is a block diagram showing a configuration example of a memory management system according to the present invention, and FIG. 2 is a block diagram showing a hardware configuration example of a computer on which the memory management system in FIG. 1 is mounted.
[0014]
2, reference numeral 21 denotes a display device such as a CRT (Cathode Ray Tube) or an LCD (Liquid Crystal Display); 22, an input device including a keyboard and a mouse; and 23, an external storage device including a HDD (Hard Disk Drive). , 24 are an information processing apparatus having a CPU (Central Processing Unit) 24a, a main memory 24b, an input / output interface 24c and the like for performing computer processing, and 25 is a CD-ROM (Compact Disc) recording programs and data according to the present invention. -An optical disk such as a read only memory (DVD) or a DVD (Digital Video Disc / Digital Versatile Disc); Programs and data drive for reading, 27 is a communication device comprising a LAN (Local Area Network) card or a modem.
[0015]
After the programs and data stored in the optical disk 25 are installed in the external storage device 23 by the information processing device 24 via the driving device 26, the programs and data are read from the external storage device 23 into the main memory 24b, and processed by the CPU 24a. Each processing unit including the memory management system shown in FIG.
[0016]
In FIG. 1, 1 is a memory management system, 2 is a process execution unit, and the memory management system 1 is a memory management unit including an area allocation unit 11, a map generation unit 12, a map information storage unit 13, and an object arrangement unit 14. With 10.
[0017]
With such a configuration, in the memory management system 1 of the present example, when an object generated by a plurality of threads is arranged in the memory at the time of executing a process in the computer, a memory area is allocated in units of threads, and the object generated by the thread Allocate in the memory area allocated to the thread.
[0018]
That is, the process allocating unit 11 allocates a process heap region in units of threads, the map generation unit 12 generates association information between the region allocated to the thread and the thread, and the map information storage unit 13 stores the association information. The information is stored in a table (thread heap area map 15), and the object placement unit 14 refers to the object generated by the thread with reference to the association information stored in the thread heap area map 15 in the map information storage unit 13. , In the area allocated to the thread.
[0019]
In the thread heap area map 15, items of a thread ID 15a in which thread identification information used to specify each thread is registered and area information 15b used to specify a memory area allocated to each thread are provided. Based on the contents of the heap area map 15, for example, an object generated by the thread Aa is arranged in a memory area specified by the address information Aa.
[0020]
As described above, in the present example, by newly providing the memory management unit 10, in the process of executing a process of a computer, when an object is generated by a thread which is a unit of execution of a process, an object generation location is dynamically changed for each thread. By controlling, objects that are frequently used are arranged close to each other.
[0021]
The dynamic control here is performed by the memory management unit 10 allocating a unique area for each thread to a heap area of the logical memory space in the process. In addition, the vicinity arrangement of objects means that the objects are continuously arranged on a memory or a storage device such as a data cache or a TLB (Translation Look-aside Buffer).
[0022]
Due to the close arrangement of the objects, the objects generated in the heap area are grouped in units of threads, and for example, there is a high possibility that an object of the same thread enters a plurality of objects in the unit data taken into the data cache.
[0023]
When a process is executed, a plurality of threads are executed. Generally, however, the data cache is valid for only one thread, and if a thread switch occurs, the data cache is not valid, and the valid data cache is restored. Be built.
[0024]
As described above, in this example, there is a high possibility that an object of the same thread enters the data cache, and as a result, the hit ratio of the data cache is improved as compared with the related art.
[0025]
Similarly, in the TLB cache, there is a high possibility that an object used for one thread exists on the same page, and by taking those pages into the TLB cache, the TLB cache hit rate during execution of the same thread is improved. .
[0026]
Furthermore, when switching threads, switching of a certain number of page files is always required.However, this number of page files is switched when the number of threads is sufficiently larger than when the objects are stored in the heap area in the order of generation. It can be seen that this example is extremely effective for large-scale applications.
[0027]
Hereinafter, the processing operation of the memory management system of this example will be described with reference to FIGS.
[0028]
FIG. 3 is a flowchart showing an example of a memory arrangement process by the memory management system in FIG. 1, FIG. 4 is an explanatory diagram showing a first processing operation example of the memory management system in FIG. 1, and FIG. FIG. 13 is an explanatory diagram illustrating a second processing operation example of the memory management system.
[0029]
As shown in FIG. 3, when there is a request to create a thread Aa in the process A (step 301), the memory management system 1 in FIG. 1 allocates an area Aa in the heap area for the process A to the thread Aa (step 301). 302), for example, as shown in the thread heap area map 15 in FIG. 1, the thread identification information (thread ID: Aa) used for specifying each thread and the memory area allocated to each thread are specified. The area information (address Aa) to be used is associated with and stored in the storage device (step 303).
[0030]
Thereafter, when there is a request to generate an object by the thread Aa (step 304), the area Aa assigned to the thread Aa is specified with reference to the thread heap area map 15 in FIG. 1, and the object is stored in this area Aa. It is arranged (step 305).
[0031]
In the following processing in FIGS. 4 and 5, an example in “JAVA (registered trademark) VM” will be described.
[0032]
“JAVA (registered trademark) VM” uses “Garbage Collection” (GC) as a heap area management technique. In this example, a case where “Generation GC” is used as a GC technique will be described.
[0033]
As shown in FIG. 4, in the “Generation GC”, the heap area is largely divided into three areas “New Generation”, “Old Generation”, and “Permanent Generation”, and among them, “New Generation” is further referred to as “Eden”. It is divided into two areas called “Survivor”.
[0034]
Whenever a new object is created in the above structure, an object is created from the “Eden” area.
[0035]
In this example, a memory management unit 10 is newly provided, and when a thread generation request is generated during the execution of a process, the memory management unit 10 acquires the thread generation request, and the memory management unit 10 maps a heap area of the process to a thread heap area map. It manages at 15.
[0036]
The memory management unit 10 secures a constant heap area for each thread over a plurality of generations used for “Generation GC”, and notifies the thread of the area.
[0037]
Note that the heap area for each thread generated at this time is statically determined in advance, and an arbitrary area can be allocated according to a request from the user.
[0038]
For example, if a request to create a thread Aa occurs during the execution of the process ((1) in FIG. 4), the memory management unit 10 obtains the notification and newly obtains the notification from the thread heap area map 15 of the memory management unit 10. An appropriate heap area is determined ((2) in FIG. 4), and a real heap area is secured ((3) in FIG. 4). A thread Aa is created based on the information ((4), (5), (6) in FIG. 4).
[0039]
FIG. 5 shows an example of object generation at the time of thread execution. When an object generation request occurs, the generation request is notified to the memory management unit 10, and the memory management unit 10 requests the object according to the thread heap area map 15. The generated object is generated in the “Eden” area of the “New Generation”.
[0040]
For example, when the process is transferred to the thread Aa during the execution of the process ((1) in FIG. 5), a request to create an object is notified to the memory management unit 10 when executing the thread A ((2) in FIG. 5). The memory management unit 10 generates the requested object in the heap area (“Eden” area) allocated to the thread Aa ((3) in FIG. 5).
[0041]
The memory management unit 10 notifies the thread Aa of the address of the generated heap area as a return value.
[0042]
As described above with reference to FIGS. 1 to 5, in the present example, the memory allocation destination of the objects generated by a plurality of threads when a process is executed in a computer (computer) is dynamically controlled, and objects frequently used are Is placed in the vicinity. That is, by allocating a unique area for each thread to a heap area of a logical memory space in a process, objects generated by one thread are continuously arranged on a memory or a storage device.
[0043]
As a result, objects generated in the heap area are grouped in units of threads, and frequently used objects are arranged close to each other, so that, for example, the same object is assigned to a plurality of objects in unit data taken into the data cache. The likelihood of thread objects entering is increased, resulting in an improved data cache hit rate.
[0044]
Furthermore, if the number of threads in one process is sufficiently large, the objects that are frequently used are arranged close to each other, so that the possibility that the objects are arranged in the same page increases. Rate can be improved.
[0045]
The present invention is not limited to the examples described with reference to FIGS. 1 to 5 and can be variously modified without departing from the gist thereof. For example, in this example, “JAVA (registered trademark) VM” has been described as an example, but the present invention is also applicable to a computer that operates in a program language other than “JAVA (registered trademark)”.
[0046]
Further, the size of the heap area (thread allocation heap) allocated to each thread may be the same for all threads or may be set differently.
[0047]
Further, in this example, the configuration example of FIG. 2 is shown as a configuration of a computer (computer), but a computer configuration without a keyboard or a drive device of an optical disk may be used. In this example, the optical disk is used as the recording medium, but an FD (Flexible Disk) or the like may be used as the recording medium. As for the installation of the program, the program may be downloaded and installed via a network via a communication device.
[0048]
【The invention's effect】
According to the present invention, frequently used objects are arranged close to each other, whereby, for example, a frequently used object from one thread is fetched when data is fetched from the data cache, and as a result, a hit in the data cache occurs. When the ratio can be improved and the number of threads in one process is sufficiently large, the objects that are frequently used are arranged close to each other, so that there is a high possibility that the objects are arranged in the same page. As a result, it is possible to improve the TLB hit rate.
[Brief description of the drawings]
FIG. 1 is a block diagram illustrating a configuration example of a memory management system according to the present invention.
FIG. 2 is a block diagram illustrating a hardware configuration example of a computer on which the memory management system in FIG. 1 is mounted.
FIG. 3 is a flowchart illustrating an example of a memory allocation process by the memory management system in FIG. 1;
FIG. 4 is an explanatory diagram showing a first processing operation example of the memory management system in FIG. 1;
FIG. 5 is an explanatory diagram showing a second processing operation example of the memory management system in FIG. 1;
[Explanation of symbols]
1: memory management system, 2: process execution unit, 10: memory management unit, 11: area allocation unit, 12: map generation unit, 13: map information storage unit, 14 object arrangement unit, 15: thread heap area map, 15a : Thread ID, 15b: area information, 21: display device, 22: input device, 23: external storage device, 24: information processing device, 24a: CPU, 24b: main memory, 24c: input / output interface, 25: optical disk, 26: drive device, 27: communication device.

Claims (6)

A memory management system for controlling memory allocation of objects generated by a plurality of threads when a process of a computer is executed,
A memory management system, comprising: a memory management unit that allocates a memory area in units of threads, and arranges an object generated by the thread in the memory area allocated to the thread. A memory management system for controlling memory allocation of objects generated by a plurality of threads when a process of a computer is executed,
Allocating means for allocating a heap area for the process in units of threads,
Storage means for storing information associated with an area allocated to a thread and the thread;
Means for arranging an object generated by a thread in an area allocated to the thread with reference to the association information stored in the storage means. A memory allocation method of an object generated by a plurality of threads when a process is executed in a computer,
A procedure for allocating a memory area for each thread;
Allocating an object generated by a thread to a memory area allocated to the thread. A memory allocation method of an object generated by a plurality of threads when a process is executed in a computer,
A procedure for allocating a heap area for the above process in units of threads,
Storing in a storage device association information between an area allocated to a thread and the thread;
Allocating an object generated by a thread to an area allocated to the thread with reference to the association information stored in the storage device. A program for causing a computer to execute each procedure in the memory arrangement method according to claim 3. A computer-readable recording medium having recorded thereon a program for causing a computer to execute each procedure in the memory arrangement method according to claim 3.

Images