WO2016121077A1

WO2016121077A1 - Dump file generation method and dump file generation device

Info

Publication number: WO2016121077A1
Application number: PCT/JP2015/052611
Authority: WO
Inventors: 雄一郎青木; 博泰西山
Original assignee: 株式会社日立製作所
Priority date: 2015-01-30
Filing date: 2015-01-30
Publication date: 2016-08-04

Abstract

In the case where a child process obtained by replicating a parent process of a Java virtual machine generates dump information, an approximately double virtual memory amount is required as compared to when the parent process is operated alone, and the approximately double virtual memory amount is necessary. If the necessary virtual memory amount exceeds a physical memory amount actually provided to a computer, a phenomenon called thrashing occurs, with the result that it takes a lot of time to access the memory, and Java program execution speed becomes lower. In the case where a child process obtained by replicating a parent process of a Java virtual machine performs dump, the sum of the virtual memory amounts of both the processes exceeds a physical memory amount, and the generation of garbage collection may occur in the parent process, a memory dump generation in the child process is terminated or temporarily stopped. When the memory dump generation is temporarily stopped, after the garbage collection in the parent process is terminated, the memory dump in the child process is restarted.

Description

Dump file generation method and apparatus

The present invention relates to a method for generating a dump file output by a computer program.

If you suspect that a memory failure such as a memory leak has occurred in a computer program (hereinafter abbreviated as "program") that runs on a computer system, collect a memory dump of the memory used by the program, and investigate the cause. It is common to elucidate. Here, the memory dump means that the contents of the memory at a certain moment are written in a file (dump file), and this writing process is called a dump.

In recent years, computer systems, particularly servers and personal computers, often have large-capacity memories. For example, servers and personal computers with more than 1 gigabyte (GB) of memory are no longer unusual. In such a computer system having a large capacity memory, the size of the memory dump also increases. In general, the memory dump size is almost the same as the memory size, so it is not uncommon for recent memory dump sizes to exceed 1 GB.

If the memory dump becomes larger, the memory dump generation time will also be longer. The shorter the memory dump generation time, the shorter the service stop time. Therefore, it is strongly desired to shorten the memory dump generation time. The demand is particularly remarkable in an enterprise computer system having a large capacity memory. The following is an example of a memory dump output by a Java virtual machine that runs a program written in the Java (registered trademark) language widely used in enterprise computer systems that support the foundation of society such as online financial processing. However, the present invention can be applied not only to the Java virtual machine and the dump file of the Java virtual machine but also to a memory dump generated by a program written in a general programming language.

A Java virtual machine is a type of virtual machine that runs programs written in the Java language. A Java virtual machine operating on a computer system equipped with a large amount of memory is often given a large Java heap memory size as a work area on the memory. Here, the Java heap memory (hereinafter abbreviated as Java heap) is a memory area for storing Java objects existing in the process of the Java virtual machine. Since the Java heap size is increasing, the size of the Java heap dump file generated by the Java virtual machine has also increased in recent years.

As described above, a memory dump is a file where the contents of memory at a certain moment are written out to a file. Therefore, if the memory is rewritten during the generation of the memory dump, the consistency of the memory dump is lost, and the memory failure analysis using the memory dump cannot be performed.

In order to prevent this, in the prior art, the execution of the Java program was stopped while the memory dump was being generated. The stop time generally increases as the Java heap size increases. If there is Java heap memory of several GB to several tens of GB, it may stop for several tens to several hundred seconds.

In order to solve this problem, Patent Document 1 proposes a method for shortening the Java virtual machine stop time when generating a memory dump. In this method, a process executing a Java virtual machine (hereinafter referred to as a parent process) duplicates its own process to generate a child process. The parent process ends the dump generation process immediately after creating the child process, and returns to the execution of the Java program.

∙ Since the created child process is created so as to have the same contents as the memory of the parent process, memory dump generation processing is executed using the memory of this child process. Since the memory space of the parent process and the child process is separated, memory rewriting by executing the Java program in the parent process does not rewrite the memory contents of the child process. In the current operating system (hereinafter referred to as OS), the execution time of child process creation processing is generally shorter than the execution time of memory dump generation processing. This method generates a memory dump with a short stop time of the parent process. can do.

US2014 / 0129880, “GENERATION OF MEMORY DUMP OF A COMPUTER PROCESS WITHOUT TERMINATING THE COMPUTER PROCESS”

However, the method of Patent Document 1 has a problem. During execution of the memory dump generation process, the parent process and the child process that duplicates the parent process operate simultaneously. As a result, the amount of virtual memory required is approximately doubled. If this required amount of virtual memory exceeds the amount of main memory actually installed in the computer (hereinafter referred to as physical memory), a phenomenon called thrashing occurs and memory access occurs. It takes a lot of time, and the execution speed of the Java program that runs in the parent process slows down.

As described in Non-Patent Document 1, thrashing is an external storage device such as a hard disk drive (hereinafter referred to as “HDD”) that stores memory (pages) of a process when the amount of virtual memory required for the process exceeds the amount of physical memory. The operation of trying to increase the free space of the physical memory by evacuating to (page out) occurs frequently.

If the required amount of virtual memory is greater than the amount of physical memory, all physical memory pages are allocated to any process. If a process here tries to access (read or rewrite) a page that is not allocated to physical memory, the page of another process is paged out, and the page that you want to access is allocated to free physical memory (page In). Therefore, data transfer between the memory and the external storage device occurs for one memory access, and the memory access takes a long time.

In the method of Patent Document 1, this thrashing occurs when the required virtual memory amount is larger than the physical memory amount, and it is expected that the memory access will take a long time, and the Java program being executed in the parent process There is a concern that the execution speed will decrease. In particular, garbage collection (Garbage Collection, hereinafter referred to as GC), which is a Java virtual machine that collects unnecessary objects in Java heap memory, involves a large amount of memory access, so it is very useful for GC when thrashing occurs. Expected to take a long time. In general, during GC execution, the Java program is stopped in order to rewrite the reference of the Java program object safely. Therefore, if thrashing overlaps with GC, the Java program stop time is expected to become very long.

This is because even if the parent process stop time due to the child process generation for memory dump is shortened, the Java program stop time during GC in the parent process that operates in parallel with the memory dump in the child process is very long Therefore, it is impossible to reduce the parent process stop time, which is the original purpose. Such a long stop time is considered to be particularly remarkable in a process called “Full GC” for collecting unnecessary objects over the entire Java heap memory.

Here, a process has been described as an example, but the same problem occurs even when processing is performed with a thread. Hereinafter, the parent process or parent thread is referred to as parent processing, and the child process or child thread that performs dumping is referred to as child processing.

When the child process generated by the parent process of the Java virtual machine dumps, and when the total amount of virtual memory required by both processes exceeds the physical memory, and when the parent process is expected to generate GC , Terminate or temporarily stop memory dump generation in child processing. In the case of temporary suspension, the memory dump in the child process is resumed after the GC in the parent process ends.

Java Java program stop time during memory dump can be shortened.

It is an example of a block diagram showing a configuration of a computer system to which the present invention is applied. It is an example of the flowchart of the child process dump production | generation part 7A in an Example. It is another example of the flowchart of the child process dump production | generation part 7A in an Example. It is another example of the block diagram which shows the structure of the computer system to which this invention is applied. It is another example of the flowchart of the dump process part 7 in an Example. It is an example of the flowchart of the exception handler process part 11D in an Example. It is an example of the flowchart of the child process production | generation part 7B in an Example. It is another example of the flowchart of the child process dump production | generation part 7A in an Example. It is an example of the flowchart of the copy page search part 7A6 in an Example. It is an example of the flowchart of the dump process part 7 in an Example.

Hereinafter, embodiments for carrying out the present invention will be described in detail with reference to the drawings.

In the first embodiment, when the parent process of the Java virtual machine replicates itself and the child process dumps, and the total amount of virtual memory required by both processes exceeds the physical memory amount, the parent process In this case, when the occurrence of GC is expected (hereinafter referred to as when a sign of GC is detected), the child process is terminated even during the memory dump. With this method, no child process exists when the parent process GC is executed, so the total amount of virtual memory required is reduced, and thrashing is suppressed.

FIG. 1 is an example of the configuration of a computer system to which the present invention is applied. The computer 1 includes a CPU 2 and a main storage device 3, an external storage device 5 such as a hard disk drive, a display device such as a liquid crystal display, an input device such as a keyboard and a mouse, and a drive device that reads a storage medium such as a DVD. I / O devices 8 such as are connected.

The main storage device 3 stores a Java virtual machine 10, a Java virtual machine 10 CP that duplicates the Java virtual machine 10, and a Java program 9 that operates on the Java virtual machine 10.

The Java virtual machine 10 includes a Java heap 4, a program execution unit 11, and a dump processing unit 7.

The Java virtual machine 10CP has a Java heap 4CP and a dump processing unit 7CP. The Java heap 4CP is a copy of the Java heap 4, and the dump processing unit 7CP is a copy of the dump processing unit 7. Since the Java virtual machine 10CP is a duplicate of the Java virtual machine 10, it naturally has a processing unit that duplicates the program execution unit 11, but is not depicted in FIG. 1 because it is irrelevant to the description of the present invention.

In the Java virtual machine 10, the program execution unit 11 executes the Java program 9 while using the Java heap 4 as a work area. In addition, the Java virtual machine 10 stops the execution of the Java program 9 performed by the program execution unit 11 according to an instruction given from the outside of the Java virtual machine 10 (for example, an interrupt instructing generation of a memory dump by the jmap command). Then, the execution of the dump processing unit 7 is started.

The dump processing unit 7 and the dump processing unit 7CP include a child processing generation unit 7B, a parent processing return unit 7C, and a child processing dump generation unit 7A. However, the child process dump generation unit 7A in the dump processing unit 7 and the child process generation unit 7B and the parent process return unit 7C in the dump processing unit 7CP, which are not necessary for the description of the invention, are not illustrated in FIG.

In the child process generation unit 7B, for example, a Linux (registered trademark) or Unix (registered trademark) OS uses a fork system call or the like, and a Java virtual machine 10 that is a parent process (a parent process when using the fork system call) Is copied to generate a child process (child process when using the fork system call). Hereinafter, in the first embodiment and the second embodiment, description will be made assuming that parent processing = parent process and child processing = child process.

Generally, a fork system call creates a child process that duplicates the process (parent process) that invoked the fork system call. However, if the parent process was operating in multiple threads, only the thread that initiated the fork system call is duplicated. do not do. The duplicate of the activated thread becomes the current thread of the child process, and there is no thread other than the current thread in the child process. Therefore, if you want to include information related to the multithread of the parent process in the memory dump, the parent process only dumps the information related to the multithread before invoking the fork system call in the parent process, and then invokes the fork system call. In the child process, only the information accessible to the current thread needs to be memory dumped.

In the parent process return unit 7C, after the child process generation unit 7B ends, the parent process ends the dump processing unit 7 and returns to the execution of the Java application 9 by the program execution unit 11.

The generated child process executes the child processing dump generation unit 7A. The external storage device 5 stores a dump file 6 generated by the child processing dump generation unit 7A using the Java heap 4CP.

FIG. 2 is an example of a flowchart of the child process dump generation unit 7A. Here, an example of terminating memory dump generation when there is a sign of GC will be described.

First, the outline of the memory dump generation method will be described. Here, the memory dump does not perform all dumps of the memory to be dumped (for example, Java heap 4) continuously, but dumps a part of memory, checks for signs of GC, and dumps the next part of memory. Check the signs of GC and repeat the process. A part of the memory can be a memory area of a predetermined size, a single or a plurality of memory areas containing a specific type of data, or a combination of the above definitions. However, it is not limited to these definitions.

Also, here, the memory area other than the memory area that has already been dumped is called undumped data. This memory dump generation method can be applied to the Java heap, and can also be applied to memory areas other than the Java heap.

In FIG. 2, first, it is confirmed whether there is undumped data (process 7A1), and if not, the child process dump generation unit 7A is terminated. If undumped data exists, it is confirmed whether there is a sign that GC is started in the parent process (process 7A3). The sign can be confirmed by the following method. When the parent process executes the GC, a specific GC execution function is started. At the beginning of this GC execution function, perform inter-process communication processing that conveys information that notifies that GC occurs from the parent process to the child process, and the child process receives inter-process communication from the parent process in processing 7A3. If the received content is information notifying that a GC will occur, it can be determined that there is a sign that the GC will start.

Another method is to check the Java heap usage of the parent process at an appropriate frequency, and if the Java heap usage exceeds a certain percentage of the Java heap amount given as an option when the Java virtual machine starts, Information indicating that a GC has occurred can be transmitted from the parent process to the child process through inter-process communication. Two methods have been described here, but the present invention is not limited to these methods.

Also, the target GC for detecting the sign may be all GCs, or may be limited to the GC that collects all unnecessary objects in the Java heap called Full IV GC. Further, the target may be limited to only other types of GC, or the target may be limited to any combination thereof.

Next, when it is confirmed that there is a sign that GC is started in the parent process in the process of 7A3, the child process end process 7A5 is executed. If the child process is generated by the fork system call, the child process end process 7A5 may end the child process using the _exit system call. At the end of the child process end process 7A5, the child process dump generation unit 7A ends. If not confirmed, dump generation processing 7A2 is executed. The dump generation process 7A2 dumps a part of the memory as described above. When the execution of the dump generation process 7A2 is completed, the process returns to the process 7A1.

In the first embodiment, when there is a sign that the parent process starts GC, the child process is terminated without waiting for the completion of the memory dump, so that the obtained memory dump may remain as a dump of a part of the memory. There is. In that case, the memory dump may be obtained again using the jmap command or the like.

In the second embodiment, when a child process that duplicates the parent process of the Java virtual machine performs a dump, and when the total amount of virtual memory required by both processes exceeds the physical memory amount, and the parent process gives an indication of GC If detected, thrashing occurs by temporarily suspending memory dump generation in the child process, thereby eliminating memory access from the child process and preventing the child process from paging out the physical memory of the parent process. It is a method to reduce the.

In the second embodiment, since the child process is not terminated, the minimum memory required by the child process remains in the physical memory. Therefore, the effect of suppressing thrashing is relatively small compared to the method of the first embodiment. Unlike Example 1, by restarting the memory dump generation process by the child process after the GC is completed, a complete memory dump is acquired with a single memory dump generation instruction (for example, an interrupt that instructs the memory dump generation by the jmap command). be able to.

FIG. 3 is another example of a flowchart of the child process dump generation unit 7A. FIG. 3 illustrates a case where memory dump generation is temporarily stopped when there is a sign of GC, and memory dump generation is resumed after the GC ends.

First, check whether there is undumped data (process 7A1), and if not, end the child process dump generation unit 7A. If undumped data exists, it is confirmed whether there is a sign that GC is started in the parent process (process 7A3).

Next, if it is not confirmed in process 7A3 that there is a sign that the parent process will start GC, the process proceeds to dump generation process 7A2. If it is confirmed that there is a sign that the parent process will start GC, the process proceeds to process 7A4.

In process 7A4, check whether GC is finished in the parent process. If it is not confirmed that the process has been completed, the process 7A4 is executed again. Process 7A4 corresponds to the child process temporarily suspending execution of the dump generation process. If the parent process can confirm that the GC has ended, the dump generation processing 7A2 is executed next. Confirmation that GC is terminated in the parent process can be performed by the following method.

When the parent process terminates GC, the GC execution function started at the start of GC execution will be terminated. Immediately before this GC execution function is terminated (for example, a return statement), an inter-process communication process is performed to transmit information notifying that the GC is terminated from the parent process to the child process. If the inter-process communication from is received and the received content is information notifying that the GC is finished, it can be confirmed that the GC is finished. Although one method has been described here, the present invention is not limited to this method.

When the dump generation process 7A2 is finished, return to process 7A1.

4 to 9, in the case of an OS such as Microsoft® Windows (registered trademark) that does not have a fork system call, the child thread (dump) generated by the parent thread while the Java virtual machine itself manages the memory in the parent thread. A method of generating a dump by a thread) will be described. In the third embodiment, the description will be made assuming that parent processing = parent thread and child processing = child thread (dump thread). When parent processing = parent process and child processing = child process, if a mechanism for sharing memory between parent and child processes (for example, file-mapped memory) is introduced, the same operation can be performed on the algorithm. It is.

First, the outline of this method will be explained. In this method, the contents of the dump target memory (page) at the time when the dump generation is instructed are copied to another page for child processing. For this reason, the child processing thread dumps another copied page while executing the Java program 9, thereby enabling dump processing while the parent and child threads operate simultaneously. At this time, the page copy is not performed collectively at the time of dump generation instruction, but is performed on a page basis on demand when the first write occurs in the dump target memory (page). This method prevents the Java program 9 from stopping for a long time. Such a page copy method is generally called copy-on-write. Further, when a GC sign is detected during dumping, the child thread is terminated and the copy page is deleted to prevent thrashing.

This method will be described in more detail with reference to FIG. Unlike the first and second embodiments, the third embodiment does not create a duplicate of the Java virtual machine, but generates a child process (child thread) as described above. In response to a dump generation instruction given from the outside of the Java virtual machine 10 or the like, the Java virtual machine 10 stops the execution of the Java program 9 performed by the program execution unit 11 and executes the child process generation unit 7B. In the child process generation unit 7B, the Java virtual machine 10 changes the attribute of all pages included in the dump target memory (for example, the Java heap 4) from read / write (READWRITE) to read-only (READONLY). Next, the Java virtual machine 10 generates a child thread and causes the child processing dump generation unit 7A to execute. After starting the execution of the child process dump generation unit 7A, the Java virtual machine 10 returns to the execution of the Java program 9.

If the Java virtual machine 10 is executing dumping for the first time and the Java program 9 is being executed, the first write to the dump target memory will occur (the main subject is the Java program 9). Therefore, an illegal memory reference exception occurs, and execution proceeds to the exception handler processing unit 11D. The exception handler processing unit 11D that processes this exception copies the dump target memory page including the address where the illegal memory reference exception has occurred, and returns the attribute of the original non-copied page to read / write (READWRITE). Resume execution where the exception occurred.

When dumping the memory to be dumped, the child process dump generation unit 7A, if the page to be dumped is the page copied by the exception handler 11D, the copied page is the page that has not been copied otherwise. Dump It is assumed that exclusive processing is appropriately performed in the exception handler processing unit 11D and the child process dump generation unit 7A. Details of the exclusion process will be described later.

Note that the third embodiment can be implemented using threads such as pthreads not only in Windows that does not have fork system calls, but also in Linux and Unix-based OSs that have fork system calls.

Hereinafter, this will be described in detail with reference to FIGS.

FIG. 5 is an example of a flowchart of the program execution unit 11. First, it is determined in step 11A whether the Java program 9 has ended. If it has ended, the program execution unit is ended, and if not, the instruction execution unit 11B is executed. The instruction execution unit 11B executes instructions constituting the Java program 9 one by one. An exception may occur in the execution of the instruction execution unit 11B. For example, an illegal memory reference exception that is an access to an illegal memory address (STATUS_ACCESS_VIOLATION exception on Windows, SIGSEGV signal on Linux and Unix OS).

Process 11C determines whether an exception has occurred. If no exception has occurred, the process returns to the processing 11A and the program execution is continued. If an exception has occurred, the exception handler processing unit 11D is executed. The exception handler processing unit 11D will be described later. After the exception handler 11D is executed, the process 11E is executed.

Processing 11E determines whether to re-execute the instruction that caused the exception handled by the exception handler. If it is re-executed, the process 11A is executed, and if it is not re-executed, the program execution unit is terminated.

FIG. 6 is an example of a flowchart of processing of the exception handler processing unit 11D. First, it is determined whether or not the illegal memory reference exception has occurred in the dump target memory area in process 11D1. If not, normal exception processing (processing 11D11) is executed. If so, the process 11D2 secures a copy page, that is, secures a memory area indicating the above-mentioned another copied page. This can be done using the mmap system call for Linux and Unix-based OSs, and the VirtualAlloc function for Windows.

Next, exclusive processing starts in processing 11D3. Next, in process 11D4, it is checked whether the page including the address that caused the illegal memory reference exception has already been registered in the copy page table.

The copy page table is a table in which the copy page secured in the process 11D2 is registered. The copy page table can be implemented as a hash table, for example, but may have other data structures.

If not registered in the copy page table, the copy page secured in process 11D2 is registered in the copy page table in process 11D5. Next, the original page contents are copied to the copy page secured in process 11D6. Next, the exclusion process is terminated in process 11D8. If not registered in the copy page table, the copy page secured in process 11D2 is released in process 11D7, and then the exclusive process is terminated in process 11D8.

Processing at the time of branch No in process 11D4 may seem useless, but by securing the copy page in process 11D2 outside the exclusive processing section, the effect of shortening the time required for exclusive processing and improving processing performance is there. If the exclusive process and the pre- and post-processes are appropriately performed, the copy page release of process 11D7 can be made outside the exclusive process section.

Next, in step 11D9, the attribute of the original page is changed to read / write (READWRITE). This can be done using the mprotect system call for Linux and Unix-based OSs, and the VirtualProtect function for Windows. By processing 11D9, illegal memory reference due to writing to this page will not occur in the future (Note that illegal memory reference due to a general bug such as Java program 9 may occur, but this is a topic outside the scope of the present invention. is there).

Finally, re-execution preparation processing is performed in processing 11D10. This is a process for re-executing the Java program 9 from the instruction that caused the illegal memory reference exception. For example, when structured exception handling is used on Windows, the exception handler function corresponds to the process of returning the macro EXCEPTION_CONTINUE_EXECUTION. On Linux and Unix OS, change the attributes related to signal processing using the sigaction system call (by setting the SA_RESTART option in the sa_flags option flag of the sigaction structure), and then start Java program 9 from the instruction that caused the exception. Can be re-executed.

FIG. 7 is another example of the flowchart of the child process generation unit 7B. First, in process 7B1, all dump target memory attributes are changed to read-only. This can be done using the mprotect system call for Linux and Unix-based OSs, and the VirtualProtect function for Windows. Next, in process 7B2, a thread for executing the child process dump generation unit 7A is activated. After the execution of this thread starts, the child process generation unit 7B ends.

FIG. 8 is another example of the flowchart of the child process dump generation unit 7A. First, it is confirmed whether there is undumped data (process 7A1), and if there is not, the child process dump generation unit 7A is terminated. If there is undumped data, the copy page search unit 7A6 is executed for the page containing the undumped data. Pages including undumped data may be extracted in the order registered in some data structure, for example, the copy page table defined in this embodiment, or the copied pages may be extracted preferentially.

By using the method of preferentially retrieving copied pages, the number of copy pages registered in the copy page table can be reduced as much as possible by combining with process 7A11 (process for deleting copy pages that have been dumped) described later. By reducing the amount of memory used, the possibility of physical memory depletion, that is, the possibility of occurrence of thrashing can be reduced.

Next, the copy page search unit 7A6 checks whether the copy page has been registered in the copy page table, and then executes process 7A6A. If the result of the copy page search unit 7A6 is 'Yes', the process 7A6A goes to branch Yes, and in process 7A7, the copy page is searched from the copy page table, the copy page is dumped, and then the process 7A11 is executed. If the result of the copy page search unit 7A6 is 'No', the process 7A6A goes to the branch No, and the original page is dumped in the process 7A8. When the process 7A8 is completed, the copy page search unit 7A13 is executed again to check whether the copy page has been registered in the copy page table, and then the process 7A13A is executed. The entity of the copy page search unit 7A13 is the same as the entity of the copy page search unit 7A6, but the numbers are separated for convenience of explanation.

The copy page search unit 7A13 detects the case where the first write from the Java program 9 to the original page occurred and the page contents were rewritten while dumping the original page (without exclusive processing) in process 7A8. To confirm. If the copy page search unit 7A13 finds that the copy page has been registered, it means that the original page was written during the dump of the original page, so the process 7A13A goes to branch Yes .

Next, the file pointer of the dump file is rewound by one page in process 7A9, the copy page is dumped in process 7A10, and process 7A11 is executed. If the result of the copy page search unit 7A13 is “No”, the process 7A13A goes to branch No and executes the process 7A11. In process 7A11, the copy page for which dumping is completed is deleted. To delete a copy page, start exclusive processing first, then use the munmap system call if it is a copy page secured using the mmap system call on Linux or Unix OS, and use the VirtualAlloc function on Windows. If it is a secured copy page, delete it using the VirtualFree function, and finally end the exclusion process.

Next, in process 7A12, it is confirmed whether there is any sign that GC will start. The method for confirming the sign has been described in the description of the first embodiment. If it is confirmed that there is a sign, the child process dump generation unit 7A is terminated, and if not, the process 7A1 is executed.

Note that in process 7A12, the amount of virtual memory that the Java virtual machine 10 is using to execute the Java program 9 and the amount of copy pages that are currently held in the copy page table are not the sign of GC. It is also possible to implement a method of determining whether or not the value exceeds a predetermined fixed percentage of the physical memory amount, and if so, proceed to branch Yes, otherwise proceed to branch No. Moreover, it can also be set as determination conditions combining these methods.

FIG. 9 is an example of a flowchart of the copy page search units 7A6 and 7A13.

As described above, since 7A6 and 7A13 are the same process, they will be explained together. First, exclusive processing is started in processing 11D3. Next, in process 7A6A, it is checked whether a copy page is registered in the copy page table. If registered, the process proceeds to process 7A6B, and if not, process 7A6C is executed. In process 7A6B, “Yes” is set in the return value of the copy page search unit, and process 11D8 is executed. In process 7A6C, “No” is set in the return value of the copy page search unit, and process 11D8 is executed. In the process 11D8, the exclusive process is terminated.

In the exclusive processing described in the description of the third embodiment, the same exclusive program can be used for the entire program, the copy page table is a hash table, and each entry in the hash table is an exclusive object. Thus, a method for shortening the time required for the exclusive process can be used, but the method of selecting the exclusive object is not limited thereto.

FIG. 10 is another example of the flowchart of the dump processing unit 7. FIG. 10 illustrates a case where a memory dump generation method is selected before executing a memory dump.

First, the dump processing unit 7 executes the dump method determination unit 7D. The dump method determination unit 7D uses either the method of the present invention for dumping according to the conventional method, that is, the method of stopping the Java program for generating the memory dump (corresponding to the processing 7E) or the method of the present invention. Determine whether to choose.

Judgment method can be fixedly determined by using options given when starting the Java virtual machine or environment variables. If you decide during execution, you can do it as follows.

First, the amount of free physical memory EM is the amount of physical memory mounted TM, the amount of Java heap 4 currently used by the program execution unit 11 JH, and the amount of memory CH used by the Java virtual machine 10 other than Java heap 4 CH And using the memory amount OM used by programs (OS etc.) other than the Java virtual machine 10 running on the computer 1,
(Formula 1) EM = TM-JH-CH-OM
It can be calculated by the formula On the other hand, the amount of memory DM required for the memory dump process is a duplicate of the parent process.
(Formula 2) DM = JH + CH
It is. Therefore, the condition that there is a sufficient amount of free physical memory is EM> DM, that is, (Equation 3) TM-JH-CH-OM> JH + CH
It is. If this is transformed,
(Formula 4) 2 × (JH + CH) <TM-OM
It becomes. (Equation 4) shows that twice the amount of memory required by the Java virtual machine 10 (JH + CH) is obtained by subtracting the amount of memory used by programs other than the Java virtual machine 10 from the amount of physical memory installed (TM-OM) Is smaller than that, it means that it can be determined that there is sufficient free physical memory. Therefore, JH, CH, TM, and OM are calculated by the dump method determination unit 7D, and if (Equation 4) is known, the process proceeds to the child process generation unit 7B. Otherwise, the dump method 7E in the conventional method is used. move on.

If it can be assumed that CH is sufficiently smaller than JH and OM is sufficiently smaller than TM, (Equation 4) becomes (Equation 5) 2 × JH <TM
It becomes. From (Equation 5), if CH is sufficiently smaller than JH and OM is sufficiently smaller than TM, if physical memory more than twice the amount of Java heap 4 used by program execution unit 11 is installed, It can be said that there is enough free physical memory. In this case, the dump method determining unit 7D calculates JH and TM, and if it is known that (Equation 5) is satisfied, the process proceeds to the child process generation unit 7B, and otherwise, the process proceeds to the dump 7E in the conventional method.

Also, the relational expression between the maximum Java heap amount Xmx given as an option when starting the Java virtual machine 10 (Equation 6) JH <Xmx
Instead of (Equation 5), (Equation 7) 2 × Xmx <TM
Can also be used. In this case, the dump method determination unit 7D calculates TM and compares it with twice the value of Xmx. If (Equation 7) is established, the process proceeds to the child process generation unit 7B, otherwise Proceed to conventional dump 7E.

Furthermore, when the GC method is the Concurrent Mark and Sweep method, the relationship between the amount of Java heap 4 used JH and the maximum amount of Java heap Xmx given as an option when starting the Java virtual machine 10 is as follows: There is:
(Formula 8) JH <α × Xmx
α is a constant of 0 <α <1. α is calculated as follows:
(Formula 9) α = (100-MinHeapFreeRatio
+ CMSTriggerRatio x MinHeapFreeRatio / 100) / 100
MinHeapFreeRatio and CMSTriggerRatio are options at the time of starting the Java virtual machine 10, and the default value of α is 0.92 because the default values are 40 and 80 respectively in the Java virtual machine of Oracle.

(Equation 5) (Equation 7) (Equation 8)
(Formula 9) TM> 2 × Xmx> 2 × JH = 2 × α × Xmx
(0 <α <1). By using (Equation 9) instead of (Equation 7), even for a computer system with a smaller TM value, that is, smaller physical memory than when (Equation 7) is used, this It can be said that the invention can be applied.

After execution of the child process generation unit 7B, the parent process next executes the parent process return unit 7C, the child process generated by the child process generation unit 7B executes the child process dump generation unit 7A, and the dump process unit Exit 7

[After the dump 7E is executed by the conventional method, the dump processing unit 7 is terminated.

As mentioned above, although the Example for implementing this invention was described, this invention is not limited to these structures, A various structure can be taken in the range which does not deviate from the meaning.

Further, software or the like that realizes each functional unit described above can be recorded on a magnetic or optical portable recording medium, or can be installed in a computer using them. Further, it can be installed on a computer by downloading via a network such as the Internet.

1 ... Computer, 2 ... CPU, 3 ... Main storage, 4 ... Java heap, 5 ... External storage, 6 ... Dump file, 7 ... Dump processing unit, 7A ... Child processing dump generation unit, 7B ... Child processing generation unit 7C ... Parent processing return part, 8 ... I / O device, 9 ... Java program, 10 ... Java virtual machine, 11 ... Program execution part

Claims

The child process generation unit of the parent process that executes the program generates a child process that duplicates the main process including the program arranged in the main memory in the main memory,
The child process dump generation unit executes a memory dump in which the child process replicated in the main memory outputs the dump target memory area to the external storage device, and detects a sign of occurrence of garbage collection in the parent process. A dump information acquisition method for a computer, characterized by suppressing a memory dump.
The child process generation unit of the parent process that executes the program generates a child process, the instruction execution unit of the parent process changes the attribute of the page in the memory area to be dumped to read-only, and a storage protection exception is generated by executing the program. When it occurs, if the occurrence of the storage protection exception is a storage area to be dumped, copy the page including the storage area,
The dump generation unit of the child process dumps the copied page when the copied page exists, and dumps the original page when the copied page exists, when the memory dump is executed. The dump information acquisition method described.
3. The dump information acquisition method according to claim 2, wherein the suppression of the memory dump is suspended until the garbage collection in the parent process is completed and resumed after the garbage collection in the parent process is completed.
The dump information acquisition method according to claim 3, wherein the sign of the garbage collection is that the amount of virtual memory to be used exceeds a predetermined percentage of the amount of physical memory.
The dump information acquisition method according to claim 1, wherein the suppression of the memory dump ends the memory dump.
The parent process includes a dump method determination unit,
The dump method determination unit accepts an instruction whether to stop generating dump information when garbage collection occurs,
The dump information acquisition method according to claim 1, wherein the dump generation unit determines whether to end the generation of dump information based on the received instruction when garbage collection occurs.
A dump information acquisition device for a computer,
A parent process that executes a program and a child process generator of the parent process that duplicates the program in the main memory and generates a child process;
A child process that suppresses a memory dump of a child process when a child process copied to the main memory executes a memory dump that outputs the dump target memory area to an external storage device and detects a garbage collection occurrence in the parent process A dump information acquisition apparatus comprising: a dump generation unit.
When a child process generation unit of a parent process that generates a child process is provided, and the instruction execution unit of the parent process changes the attribute of the page in the memory area to be dumped to read-only, and a storage protection exception occurs due to execution of the program , If the occurrence of the storage protection exception is a storage area to be dumped, copy the page including the storage area,
The dump generation unit of the child process dumps the copied page when the copied page exists, and dumps the original page when the copied page exists, when the memory dump is executed. The dump information acquisition device described.
The dump information acquisition apparatus according to claim 8, wherein the suppression of the memory dump is interrupted until the garbage collection in the parent process is completed and resumed after the garbage collection in the parent process is completed.
10. The dump information acquisition apparatus according to claim 9, wherein the sign of the garbage collection is that the amount of virtual memory to be used exceeds a predetermined percentage of the amount of physical memory.
The dump information acquisition apparatus according to claim 7, wherein the suppression of the memory dump ends the memory dump.
The parent process includes a dump method determination unit,
The dump method determination unit accepts an instruction whether to stop generating dump information when garbage collection occurs,
The dump information acquisition apparatus according to claim 7, wherein the dump generation unit determines whether to end the generation of dump information based on the received instruction when garbage collection occurs.