JP2008197980A - Failure analysis file weight reduction device for distributed parallel program, its method and its program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To reduce the weight of a failure analysis file for a distributed parallel program to effectively utilize the storage capacity of a storage medium and also shorten I/O (input/output) time. <P>SOLUTION: The file weight-reducing device outputs the same content of a shared memory independently to individual core. gmem files without duplicate output thereof to a failure analysis file of each process, and performs writing into gmlist so that the failure analysis file of each process refers to the core. gmem file concerned. According to this, the file weight can be reduced in either case input or output, and processing can be simplified. <P>COPYRIGHT: (C)2008,JPO&INPIT

Description

  The present invention relates to an input / output file weight reduction device for a failure analysis file of a parallel program in which a plurality of processes operate using a shared memory. More specifically, the present invention relates to a lightweight file for use in reducing input / output of a failure analysis file. The present invention relates to a conversion device.

In general, when a failure occurs during process execution, the memory image (context, stack, data) being executed is output to a file, and the cause of the failure is investigated by analyzing the file. ing. (This file is hereinafter referred to as the failure analysis file.)
A failure analysis file is created for each process with one process as a unit.

  Here, in the case of a distributed parallel program, the program is divided into a plurality of processes and executed, but a failure does not always occur due to only one process.

  Therefore, it is necessary to output failure analysis files for all processes and analyze them.

  However, depending on the implementation method of the distributed parallel program, a part of the memory may be shared to facilitate data transfer between processes.

  In such an implementation method, when a failure occurs in the distributed parallel program and the memory image being executed is output to the failure analysis file, even if it is the contents of the shared memory part, all Duplicate output to the process failure analysis file.

  Therefore, there is a problem that the total size of the failure analysis file becomes large and input / output takes time.

  For example, consider a case where a failure occurs in a program that is distributed and executed in four processes.

  As shown in FIG. 5, a memory image during execution of each process is represented by core. proc. 110, core. proc. 120, core. proc. 130 and core. proc. 140 are output to four failure analysis files.

  At this time, gmem201, gmem202, gmem203, and gmem204, which are images of the shared memory portion, are output to the failure analysis files of all processes.

  As a result, as shown in the figure, there is a problem that an image of the shared memory portion is output in duplicate in all failure analysis files.

  Here, the operation procedure at the time of conventional gmem output will be described with reference to FIG.

  First, core. The virtual address and the offset size of gmem are written to proc gmlist (S31). Next, core. proc. The contents of gmem are written in xxx (S32).

  The procedure (S31) and (S32) is repeated until processing is performed on all shared memories (S33).

  The conventional failure analysis file output system having such an operation procedure of the output unit has the core. The contents of the shared memory are output in duplicate with the proc file (see, for example, Patent Document 1).

  In addition, a conventional operation procedure when gmem is input will be described with reference to FIG.

  First, core. The virtual address and the offset size of gmem are read into proc gmlist (S41).

  Next, core. proc. Data of the size is read into the virtual address from the offset of gmem to xxx (S42).

Then, the procedure (S43) and (S42) are repeated (S43) until processing is performed on all the shared memories.
JP 11-312103 A

  In the above prior art, core. The contents of the shared memory are input / output redundantly in the proc file.

  Therefore, there has been a problem that the storage capacity of the storage medium cannot be effectively utilized both at the time of input and at the time of output. In addition, the problem that I / O (Input / Output) time becomes long also occurred.

  Here, as a means for avoiding the above-described overlapping output, a method in which a part of the failure analysis file outputs a representative of the overlapping portion can be considered. However, it was difficult to realize for several reasons as follows.

  First, there is a problem that the logical address of the shared memory portion is not always the same in all processes.

  Further, even if it is determined which process is representatively output, there is a further problem that means for notifying the representative process to all processes is necessary.

  In addition, when one process represents and writes a duplicated portion of the failure analysis file, the representative process eventually performs the same processing as before.

  Therefore, the output time cannot be shortened.

  In addition, even if it becomes possible to solve the above-described problem and it is possible to avoid duplicate output, means for restoring when reading the information of the duplicate part of the failure analysis file output by the representative process is required.

  Accordingly, the present invention solves the above-described problem, and reduces the weight of a failure analysis file for a distributed parallel program, which does not duplicately output the same shared memory contents to the failure analysis file of each process, its method, and its program The purpose is to provide.

  According to the present invention, there is provided a file weight reduction device for reducing the weight of a failure analysis file of a distributed parallel program, a shared memory information listing means for writing shared memory information to a failure analysis program, and new sharing information as a file. There is provided a file weight reduction apparatus comprising: a shared information file generating means for generating a shared information file; and a means for sharing and using the shared information file based on the list information.

  In the file weight reduction apparatus and method and the program thereof, the information written in the failure analysis program in the shared memory information listing unit may be a virtual address, a file name, and a size of the shared memory.

  According to the present invention, it is possible to prevent the same shared memory contents from being duplicated in the failure analysis file of each process. As a result, the size of the entire failure analysis file can be reduced, thereby making it possible to effectively use the storage capacity of the storage medium.

  Next, the best mode of the present invention will be described with reference to the drawings.

[Embodiment]
(Configuration of the embodiment)
The configuration of the failure analysis file group in the embodiment of the present invention is shown in FIG. FIG. 2 shows the overall configuration including the failure analysis file group.

  The failure analysis file group in FIG. 1 includes core. proc, and core.core, which is a failure analysis file of the shared memory portion. gmem.

  As shown in FIG. 2, the embodiment of the present invention includes a context output unit 101, a stack output unit 102, a gmlist output unit 103, a core. gmem confirmation unit 104, gmem creation / output unit 105, data output unit 106, and failure analysis file input unit, context input unit 201, stack input unit 202, core. gmem. list input unit 203, core. A gmem input unit 204, a data input unit 205, and a failure analysis file group 301 are provided.

(Operation of the embodiment)
Next, the operation of the embodiment of the present invention will be described in detail.

  In the description of the operation, the flowchart shown in FIG. 3 is used in addition to FIGS. First, the context output unit 101 and the stack output unit 102 include the core. The context segment and stack segment are output to the proc file.

  Next, the gmlist output unit 103 receives the virtual address of the shared memory, core. gmem file name, core. gmem size is set to core. It is output to the gmlist segment of the proc file (S10).

  Furthermore, the core. gmem confirmation unit 104 receives core. gmem. It is checked whether a file xxx already exists (S11).

  Here, core. gmem. If a file xxx exists, the file is not created in order to avoid duplication of files having the same contents. Then, the process proceeds to the next shared memory portion.

  On the other hand, if it does not exist yet, core. In the gmem creation / output unit 105, core. gmem. A file called xxx is created (S12).

  Further, the gmem creation / output unit 105 stores the contents of the shared memory as core. gmem. Write out to xxx (S13).

  The operations (S10), (S11), (S12), and (S13), which are operations for writing the shared memory, are sequentially performed on all the shared memories. For all the shared memories, the work of writing the shared memory is completed when the processing is completed (S14).

  Core. gmem. The file name “xxx” is another core. It should not overlap with the gmem file name.

  For this purpose, the xxx portion is made unique by, for example, attaching a memory region number of the shared memory.

  Finally, the data output unit 106 of FIG. The data segment is output to the proc file (S15).

  On the other hand, the operation when reading the failure analysis file during debugging will be described with reference to FIG.

  First, the context input unit 201 and the stack input unit 202 read the context segment and stack segment in the failure analysis file group 301 into the memory.

  Next, core. The gmlist input unit 203 stores the core. The virtual address to be expanded of the shared memory and the core.core in which the entity is written from the gmlist segment of the proc file. The gmem file name and size are read (S21).

  Subsequently, based on the read information, core. In the gmem input unit 204, the corresponding core. The gmem file name is read into the virtual address (S22).

  Then, the operation of reading this shared memory, (S21) and (S22) are sequentially performed on all the shared memories (S23).

  Finally, the data input unit 205 displays the core. The data segment of the proc file is read into the memory (S24).

(Effect of embodiment)
The first effect is that the size of the entire failure analysis file can be reduced.

  The reason is that the same shared memory contents are not duplicated and output to the failure analysis file of each process, and each core. output to the gmem file, and core. This is because duplication is avoided by writing to gmlist so as to refer to the gmem file.

  The second effect is that the time taken to input / output the failure analysis file can be shortened. The reason is that the size of the entire failure analysis file is reduced as described above.

  The above two effects solve the problems of the present invention that the storage capacity of the storage medium cannot be used effectively at the time of input and output, and that the I / O (Input / Output) time becomes long. It becomes possible to do.

  Furthermore, in the present invention, the core. core.shared with the proc file. The gmem file is distinguished as separate within the file. Therefore, core. When deleting the proc file, there is no concern that the shared file will be deleted together.

  Therefore, without considering the shared file, core. There is also an effect that the proc file can be deleted.

  In addition, in the present invention, the shared core. The process of dividing the gmem file itself is not performed. Therefore, the core. There is also an advantage that processing such as decoding the gmem file is not necessary.

  As a result, there is also an effect that the processing when the failure analysis file is expanded on the memory becomes quick.

  The present invention can be applied to the use of reducing a failure analysis file of a parallel program in which a plurality of processes operate using a shared memory.

It is a conceptual diagram showing the structure of the failure analysis file group of this invention. It is a figure showing the basic composition of the present invention. It is a flowchart showing the operation | movement procedure in the output part of this invention. It is a flowchart showing the operation | movement procedure in the input part of this invention. It is a conceptual diagram showing the structure of the failure analysis file group of a prior art. It is a flowchart showing the operation | movement procedure in the output part of a prior art. It is a flowchart showing the operation | movement procedure in the input part of a prior art.

Explanation of symbols

101 Context output unit 102 Stack output unit 103 gmlist output unit 104 core. gmem confirmation unit 105 gmem creation / output unit 106 data output unit 201 context input unit 202 stack input unit 203 core. gmem. list input unit 204 core. gmem input unit 205 data input unit 301 failure analysis file group

Claims (11)

A file weight reduction device for reducing the weight of a failure analysis file of a distributed parallel program,
Shared memory information listing means for writing shared memory information to the failure analysis program as list information;
A shared information file generation means for newly generating shared information as a file;
Means for sharing and using the shared information file based on the list information;
A file lightening device comprising: The file lightening device according to claim 1,
A file weight reduction apparatus characterized in that, when a shared information file having the same content already exists, no new shared information file is created. The file lightening device according to claim 1 or 2,
In the shared memory information listing means, the information to be written into the failure analysis program is a virtual address, a file name and a size of the shared memory. The file lightening device according to any one of claims 1 to 3,
The shared use refers to outputting a failure analysis file on a recording medium. The file lightening device according to any one of claims 1 to 3,
The shared use means that the failure analysis file is expanded on a memory. A file weight reduction method for reducing a failure analysis file of a distributed parallel program,
A shared memory information listing step for writing shared memory information to the failure analysis program as list information;
A shared information file generation step for newly generating shared information as a file;
Sharing and using the shared information file based on the list information;
A method for reducing the weight of a file. The file lightening method according to claim 6,
A file weight reduction method characterized in that, when a shared information file having the same content already exists, a new shared information file is not created. The file lightening method according to claim 6 or 7,
In the shared memory information listing step, the information to be written to the failure analysis program is a virtual address, a file name, and a size of a shared memory. The file lightening method according to any one of claims 6 to 8,
The shared use refers to outputting a failure analysis file on a recording medium. The file lightening method according to any one of claims 6 to 8,
The shared use refers to developing a failure analysis file on a memory, and a method for reducing the weight of a file.   A program for causing a computer to execute the file lightening method according to any one of claims 6 to 10.

Images