JP2016095792A - Information processing device, control method thereof, and program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a mechanism for outputting a dump file only when required in the case that insufficient memory occurs without needing a user operation.SOLUTION: An information processing device secures a memory area according to a memory request from an application, generates an exception when the memory area cannot be secured, releases no longer needed memory area secured by other applications to execute GC processing for rearranging a memory area when the exception is generated, does not generate a heap dump file showing a state of a memory after executing GC processing if the exception is generated in a development stage of the application, and generates the heap dump file if the exception is not generated in the development stage of the application.SELECTED DRAWING: Figure 5

Description

  The present invention relates to an information processing apparatus that controls generation of a log file (heap dump file), a control method therefor, and a program.

  Conventionally, Java (registered trademark) is widely known as an execution environment of an application (hereinafter referred to as an application) that operates on an image forming apparatus (MFP). In this execution environment, an application written in the Java language (hereinafter referred to as a Java application) operates on the Java Virtual Machine (Java VM). When a Java application uses memory, it makes a memory request to the Java VM. JavaVM reserves a fixed area in advance as a memory area (Java heap area) that can be used by the Java application from the memory area of the MFP, and if a memory request is received from the Java application, is there a free space in the Java heap area? Confirm. If there is a free space, the Java VM makes the memory area available to the Java application according to the request from the Java application. On the other hand, when there is no free space in the Java heap area, the Java VM generates an exception (OutException) called OutOfMemoryError, and notifies the Java application of the exception. When this OutOfMemoryError occurs, a log file called a heap dump file is generally generated in order to identify the cause of OutOfMemoryError. This heap dump file is a file representing the state in the Java heap area, and by analyzing this file, the cause of OutOfMemoryError can be specified. However, in order to generate this heap dump file, it is necessary to perform a garbage collection (GC) process before generating the heap dump file in order to accurately know the memory usage status of the Java heap area. This GC process is a process executed by the Java VM, and operations related to all Java applications are stopped during the execution. In particular, in the case of FullGC which deletes not only the New area in the heap area but also objects existing in the Old area and the Permanent area, the stop time becomes long.

  Therefore, if a heap dump file is generated every time OutOfMemoryError occurs, there is a problem that the entire system frequently stops. Patent Document 1 proposes a technique for generating a log file only when a specific type of exception occurs.

JP 2008-186378 A

  However, the above prior art has the following problems. In the above prior art, it is possible to switch whether heap dump files are generated according to the type of exception. However, in the above prior art, since the presence / absence of generation is switched depending on the type of exception, when the same type of exception occurs in a short time, it is not possible to switch whether heap dump file is generated. There is a problem of generating. As a situation where it is necessary to switch whether heap dump files are generated, for example, there are the following situations.

  When a Java application that operates on the MFP is created, the application creator needs to declare the maximum memory usage amount used by the Java application. Note that the maximum memory use amount is described in a file that describes the attribute of the application called a MANIFEST file bundled with the Java application. This maximum memory usage is used to restrict the installation of the Java application so that the total memory amount of the Java application operating on the MFP does not exceed the memory amount of the Java application that can be used in the MFP.

  In order to check the maximum memory usage, the application creator operates a servlet type Java application called a maximum memory usage measurement tool (hereinafter referred to as a measurement tool) on the MFP. This measurement tool is a tool that uses a memory area other than the estimated memory amount set by the application creator, and changes the free capacity to only the estimated memory amount. Using this measurement tool, the application creator determines the maximum estimated memory amount that does not generate an OutOfMemoryError of the created Java application. However, it is necessary to generate OutOfMemoryError many times in the determination. Therefore, there is a situation where it is desired to generate a heap dump file when OutOfMemory occurs due to a failure such as a memory leak, but does not want to generate a file when OutOfMemoryError that is intentionally generated to determine the maximum amount of memory used. The above prior art cannot cope with such a situation.

  The present invention has been made in view of the above problems, and an object thereof is to provide a mechanism for outputting a dump file only when necessary when a memory shortage occurs without requiring a user operation. To do.

  The present invention is an information processing apparatus that secures a memory area according to a memory request from an application and generates an exception if the memory area cannot be secured, and secures it in another application when the exception occurs. An execution unit that executes a GC process for releasing a memory area that is no longer needed and rearranges the memory area, and when the GC process is executed by the execution unit, based on information stored in the information processing apparatus A determination unit that determines whether or not the exception occurs in the application development stage; and the execution unit that determines that the exception occurs in the application development stage based on a determination result by the determination unit. The heap dump file indicating the state of the memory after executing the GC process is not generated, and the application If the occurrence of the exception in the application development stage, characterized in that it comprises generating means for generating the heap dump file.

  According to the present invention, a dump file can be output only when necessary when a memory shortage occurs without requiring a user operation.

FIG. 2 is a block diagram illustrating a controller unit 120 of the image forming apparatus 100 according to the first embodiment. FIG. 2 is a block diagram illustrating a software configuration of a controller unit 120 according to the first embodiment. The figure showing the module structure of JavaVM202 and OS203 which concerns on 1st Embodiment. FIG. 4 is a diagram illustrating a specific example of a heap dump file generated by the image forming apparatus 100 according to the first embodiment. 6 is a flowchart showing processing when OutOfMemoryError occurs according to the first embodiment. It is a flowchart figure showing the process of GC which concerns on 1st Embodiment. The figure showing the structure of the Java application for development which concerns on 1st Embodiment, and the Java application for products. The figure showing the flow which measures the maximum memory usage of a Java application. 12 is a flowchart showing processing when OutOfMemoryError occurs according to the second embodiment.

  Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings. The following embodiments do not limit the present invention according to the claims, and all combinations of features described in the present embodiments are not necessarily essential to the solution means of the present invention. .

<First Embodiment>
<Configuration of image forming apparatus>
In the following, a first embodiment of the present invention will be described with reference to FIGS. First, a controller unit of the image forming apparatus 100 according to the present embodiment will be described with reference to FIG. Here, an image forming apparatus 100 will be described as an example of an information processing apparatus to which the present invention can be applied.

  The image forming apparatus 100 includes a controller unit 120, an operation unit 106, a scanner 116, and a printer 118. The controller unit 120 includes a CPU 101, a RAM 102, a ROM 103, an HDD 104, an operation unit I / F 105, a network unit 107, an image bus I / F 109, a power management unit 110, a RIP 113, a device I / F 114, and an image processing unit 119.

  The controller unit 120 not only performs input / output of image information and device information, but also performs control of the entire apparatus and control of printing out data provided from outside via a network. Control is also performed in communication functions including an electronic mail transmission function via a network.

  The CPU 101 starts the system based on a boot program stored in the ROM 103, reads a control program stored in an HDD (hard disk drive) 104 on the system, and executes various processes using the RAM 102 as a work area. With this control program, it is possible to execute control such as a Java program. The HDD 104 stores the various control programs, and also stores image data and information related to all communication methods of the network unit 107 described later.

  A RAM 102, a ROM 103, and an HDD 104 are connected to the CPU 101 via a system bus 111. Further, an operation unit I / F 105, a network unit 107, an image bus I / F 109, and a power management unit 110 are connected via a system bus 111.

  The operation unit I / F 105 is an interface between the operation unit 106 and the controller unit 120, and the CPU 101 outputs a signal generated by transferring image data to be displayed on the operation unit 106 to the operation unit 106 and operating input in the operation unit 106. Transfer to. The operation unit 106 includes a current setting state for each function related to image processing, a display unit for displaying an information input screen for inputting setting information related to each function, a key for a user to input setting information for each function, and the like. It has an input part containing.

  The power management unit 110 manages power OFF and power ON of the image forming apparatus 100. When the power supply is detected, as described above, the CPU 101 starts up the system based on the boot program stored in the ROM 103 and executes the control program stored in the HDD 104 on this system.

  The network unit 107 is connected to the LAN 108 and inputs / outputs information via the LAN 108. When a web server or an external device 400 is connected to the LAN line, information can be acquired from the server via the LAN 108. It is also possible to connect to the Internet via a proxy server in the LAN line and acquire web content from a web server on the Internet.

  The image bus I / F 109 is a bus bridge that connects the system bus 111 and the image bus 112 and converts the data structure. The image bus 112 is composed of a PCI bus capable of transferring image data at high speed or a bus conforming to the IEEE 1394 standard. A RIP (raster image processor) 113, a device I / F 114, and an image processing unit 119 are connected to the image bus 112.

  The RIP 113 expands the PDL code into a bitmap image. The device I / F 114 connects the scanner 116 and printer 118, which are image input / output devices, and the controller unit 120, and performs synchronous / asynchronous conversion of image data. Here, the device I / F 114 and the scanner 116 are connected via the cable 115, and the device I / F 114 and the printer 118 are connected via the cable 117, respectively.

  The image processing unit 119 performs compression / decompression processing such as JPEG on multi-valued image data and JBIG, MMR, MH, etc. on binary image data. Further, correction, processing, and editing such as printer correction and resolution conversion are performed on the input image data and the output screen. As described above, the CPU 101 of the controller unit 120 comprehensively controls access to various devices connected to the system bus 111 based on each control program, and receives image information from the scanner 116 via the device I / F 114. Read. Further, after the image information that has been read is subjected to predetermined processing, the image information is output to the printer 118 via the device I / F 114. Further, HTML data and image data acquired through the network unit 107 are analyzed and converted, and stored in the HDD 104 or displayed on the operation unit 106.

<Software configuration>
Next, a module configuration of software that operates on each hardware such as the CPU 101 and the HDD 104 of the image forming apparatus 100 will be described with reference to FIG. Note that the processing in each of these modules is realized by reading out a program stored in the ROM 103 or HDD 104 and executing the processing using the RAM 102 as a work area in accordance with an instruction from the CPU 101. All information generated by executing each process is stored in the RAM 102 or the HDD 104. Since the processing in each module is the same in the following, description thereof is omitted below.

  The OS 201 is a module that performs memory management, input / output management, and process management, and performs processing similar to that of a general OS. The Java VM 202 is a virtual machine that operates a Java program by executing a Java byte code stored in the ROM 103 or the HDD 104.

  The application platform 203 is a module that manages and executes an application life cycle such as starting, stopping, installing, and uninstalling at least one or more Java applications (hereinafter referred to as Java applications or applications) on a single Java VM 202. It is. The application platform 203 includes a library and a service that are commonly used by the application A 204 and the application B 205.

  The application A 204 and the application B 205 are byte codes of a Java program that operates on the application platform 203, and operate using a library or service that the application platform 203 has. Further, the application A 204 and the application B 205 can be individually installed in the image forming apparatus 100 and activated on the application platform 203. The application C 206 is an application program other than the Java application, for example, a C language application, and operates on the OS 201.

<Processing of Java VM 202 and Platform 203>
Next, detailed processing of the Java VM 202 and the application platform 203 will be described with reference to FIG. The Java VM 202 includes a bytecode execution unit 301, a class loader management unit 302, a GC execution unit 303, a memory control unit 304, a heap dump file information generation unit 305, and an OutOfMemoryError generation unit 306. The application platform 203 includes an application management unit 307, a heap dump file generation determination unit 308, and a heap dump file generation execution unit 309.

  The application management unit 307 is for managing and executing the life cycle of an application such as installing, starting, stopping, and uninstalling a Java application, and performs the same processing as general OSGi. The bytecode execution unit 301 interprets the bytecode of the application activated by the application management unit 307 and executes the application process. The bytecode execution unit 301 transmits a memory use request to the memory control unit 304 when using the Java heap memory for processing such as application object generation.

  The class loader management unit 302 generates and manages a class loader, and dynamically loads a Java class so that the byte code execution unit 301 can use it. In addition, when the library or service class used by the application activated by the application management unit 307 is not loaded, the class loader management unit 302 loads the class and makes it usable.

  When the memory control unit 304 receives the memory use request, the memory control unit 304 checks the use state of the Java heap memory area (hereinafter referred to as a memory area). If there is a free area, the memory control unit 304 returns this memory area. If there is no free area, the memory control unit 304 requests the OutOfMemoryError generating unit 306 to generate OutOfMemoryError. In addition, the memory control unit 304 stores information indicating which memory of which Java application uses how much memory in the HDD 104. In addition, the memory control unit 304 requests the GC execution unit 303 to execute a GC (Garbage Collection) process. Details of the GC processing will be described later with reference to FIG. Further, the memory control unit 304 makes a heap dump file generation determination request to the heap dump file generation determination unit 308 and makes a heap dump file information generation request to the heap dump file information generation unit 305. The GC execution unit 303 performs GC processing to delete Java objects that are using the memory area and that are no longer used. The GC process is executed when a GC execution request from the memory control unit 304 or a memory area exceeding a certain level is used.

  The OutOfMemoryError generating unit 306 generates an OutOfMemoryError exception and notifies the memory request source application of this exception. Detailed processing of generating an exception and notifying an application is the same as a general mechanism, so description is omitted. The heap dump file generation determination unit 308 determines whether or not to generate a heap dump file based on conditions described later. The heap dump file information generation unit 305 acquires information indicating the state of the memory area from the HDD 104. The heap dump file generation execution unit 309 generates a heap dump file based on the information acquired by the heap dump file information generation unit 305.

<GC processing>
Next, the GC process performed by the GC execution unit 303 will be described with reference to FIG. The processing described below is realized by reading a program stored in the ROM 103 or the HDD 104 and executing the processing using the RAM 102 as a work area in accordance with an instruction from the CPU 101. Here, the GC process indicates a process of automatically releasing an unnecessary area among memory areas dynamically secured by a program such as a Java application.

  First, in step S <b> 201, the GC execution unit 303 stops other processes and controls the entire system of the image forming apparatus 100, which is generally called “stop the world”, to stop. Subsequently, in S202, the GC execution unit 303 searches for objects that are not referenced (not used) among objects that are GC targets in the memory area. As a result, if there is an unreferenced object in S203, the GC execution unit 303 deletes all the objects.

  In step S204, the GC execution unit 303 rearranges the memory areas in order to prevent fragmentation (fragmentation) of the memory areas. In step S <b> 205, the GC execution unit 303 stores the state of the memory area after the rearrangement of the memory area (the state of which object is using which memory) in the HDD 104. Note that the information stored in the HDD 104 in S205 is the content described in the heap dump file. In step S206, the GC execution unit 303 resumes the execution of the process stopped in step S201, and resumes the entire system.

<Maximum usage>
Here, with reference to FIG. 8, an example of a method for examining the maximum memory usage of the Java application created by the application creator using the measurement tool will be described.

  First, the created Java application and measurement tool are installed in an image forming apparatus such as an MFP. Then, the estimated memory amount is set with the measurement tool (from 801 to 802). Thereafter, the development Java application is operated to check whether OutOfMemoryError generated due to a memory shortage occurs (803). Here, if OutOfMemoryError occurs, it can be understood that the Java application for development uses a memory size larger than the estimated memory size (804). Therefore, the application creator sets an estimated memory amount that is smaller than the set estimated memory amount in the measurement tool, and operates the development Java application again.

  On the other hand, if OutOfMemoryError does not occur, it can be seen that the development Java application uses a memory size smaller than the estimated memory size (805). Therefore, the application creator sets an estimated memory amount that is larger than the set estimated memory amount in the measurement tool, and operates the development Java application again. The application creator repeats these operations, determines the maximum estimated memory amount that does not generate OutOfMemoryError, and describes this value as the maximum used memory amount in the MANIFEST file.

  Therefore, generating and outputting a heap dump file every time OutOfMemoryError occurs in the adjustment stage of the maximum memory usage using the measurement tool, the efficiency is significantly reduced. Therefore, in the present embodiment, whether or not heap dump files are generated is suitably switched. In addition, if the method of this embodiment is used, the presence or absence of a heap dump file generation can be switched without requiring input from an operator or the like.

<Switching process>
Next, with reference to FIG. 5, a description will be given of a switching process for switching the presence / absence of a heap dump file depending on the situation when an OutOfMemoryError is generated by each module of the Java VM 202 and the application platform 203. FIG. The processing described below is realized by reading a program stored in the ROM 103 or the HDD 104 and executing the processing using the RAM 102 as a work area in accordance with an instruction from the CPU 101.

  In response to a Java application memory request from the bytecode execution unit 301, the memory control unit 304 notifies the OutOfMemoryError generation unit 306 of an OutOfMemory generation request when the requested memory cannot be secured. When the OutOfMemory generation request is received, the OutOfMemoryError generation unit 306 generates an OutOfMemoryError exception in S101. When the OutOfMemoryError generating process by the OutOfMemoryError generating unit 306 is completed, the memory control unit 304 transmits a GC process execution request to the GC executing unit 303. When the GC process execution request is received, in step S102, the GC execution unit 303 executes the GC process described with reference to FIG. Thereafter, in S103, the memory control unit 304 transmits a heap dump file generation determination request to the heap dump file generation determination unit 308.

  When a heap dump file generation determination request is received, in S104 to S106, the heap dump file generation determination unit 308 determines whether to generate a heap dump file from the following conditions. Specifically, in the determination of S104 to S106, it is determined whether or not an OutOfMemoryError has occurred in the development stage of the Java application, and it is determined whether or not to generate a heap dump file. Note that the development stage of the Java application normally means that the development of the image forming apparatus 100 itself has been completed. Here, a case where three conditions are used will be described as an example.

  The first condition is determination as to whether or not the image forming apparatus 100 has completed product development (S104). Information (first information) as to whether or not product development has been completed can be determined using phase information stored in the ROM 103. The phase information is defaulted during product development, and is changed from product development to development completion only at the time of factory shipment (when the image forming apparatus 100 is sold). Therefore, the phase information cannot be changed by the user.

  A specific example will be described. The application creator uses the measurement tool to measure the maximum memory usage of the created Java application for development using the image forming apparatus 100 after factory shipment. For this reason, when OutOfMemoryError is generated by the measurement tool, the determination in S104 is YES. On the other hand, if OutOfMemoryError occurs due to a memory leak or the like during product development of the image forming apparatus 100, the determination in S104 is NO.

  The second condition is determination as to whether or not to perform code signature authentication when installing the Java application (S105). Whether or not to perform this code signature authentication is determined with reference to a code signature authentication flag stored in the HDD 104. This code signature authentication flag (second information) has setting values with and without authentication, and can be freely changed by the application creator.

  Here, a method of using the code signature authentication flag will be described with reference to FIG. There are two types of Java apps, one for development and one for products, and the configuration is different as shown in FIG. When creating a Java application for a product, as shown in 701, it is created in the same procedure as application distribution using a general code sign certificate. Specifically, hash values for the three created files (Java program, MANIFEST file, and product license file) are taken, and the hash values are encrypted. Also, a code signing certificate is acquired from the server (certificate authority). Then, the encrypted hash value, the three files, and the code signature certificate are collected as one jar file to be a Java application.

  On the other hand, when creating a development Java application, as shown in 702, the created three files (Java program, MANIFEST file, and development license file) are combined into one jar file to create the development Java application. To do. Since the development Java application does not perform code signature authentication, it cannot be installed in the image forming apparatus 100 when the code signature authentication flag stored in the HDD 104 of the image forming apparatus 100 is authenticated. A specific example will be described. When the application creator measures the maximum memory usage of the created Java application for development using a measurement tool, the code signature authentication flag is authenticated in order to install the development Java application in the image forming apparatus 100. None. Therefore, when OutOfMemoryError is generated by the measurement tool, the determination in S105 is NO. On the other hand, since only a commercially available Java application can be installed after the MFP is shipped from the factory, the determination in S105 when OutOfMemoryError occurs is YES.

  The third condition is determination as to whether or not to check the license file included in the Java application (S106). Whether or not to check the license file is determined with reference to a license check flag stored in the HDD 104. The license check flag (third information) has setting values with and without a check, and can be freely changed by an application creator. The Java application created by the application creator as shown in FIG. 7 includes product license information or development license information as a license file. The Java application including the development license information cannot be installed in the MFP when the license check flag stored in the HDD 104 of the image forming apparatus 100 is checked.

  A specific example will be described. When the application creator measures the maximum memory usage of the created Java application for development by using a measurement tool, the license check flag is not checked in order to install the development Java application in the image forming apparatus 100 I have to. Therefore, when OutOfMemoryError is generated by the measurement tool, the determination in S106 is NO. On the other hand, when a commercially available Java application is installed after the image forming apparatus 100 is shipped from the factory, the license check is always performed, so that the determination in S106 when OutOfMemoryError occurs is YES.

  The heap dump file generation determination unit 308 proceeds to S107 only when S104 is YES and S105 and S106 are NO in the above three determination results, and transmits a determination result indicating that no heap dump file is generated to the memory control unit 304. Then, the process proceeds to S109. On the other hand, if the determination result is other than the above determination result, the heap dump file generation determination unit 308 proceeds to S108, transmits the determination result that the heap dump file is generated to the memory control unit 304, and proceeds to S109.

  When the determination result is received, in S109, the memory control unit 304 determines whether or not this result indicates that a heap dump file has been generated. If this determination result indicates that no heap dump file is generated, the process ends without outputting the heap dump file. On the other hand, if the determination result is that a heap dump file is generated, the process proceeds to S110, and the memory control unit 304 transmits a heap dump file information generation request to the heap dump file information generation unit 305. Receiving this, the heap dump file information generation unit 305 acquires the current heap memory status information. Subsequently, in S111, the heap dump file information generation unit 305 transmits the acquired content to the heap dump file generation execution unit 309. In step S112, the heap dump file generation execution unit 309 that has received this generates a heap dump file having the received contents. Thereby, a heap dump file as shown in FIG. 4 is generated. In the heap dump file of FIG. 4, the object ID, the class that generated the object, the object size, and the reference to the generated object are displayed for each line.

  As described above, the information processing apparatus (image forming apparatus 100) according to the present embodiment secures a memory area in accordance with a memory request from the Java application, and generates an exception if the memory area cannot be secured. Further, when an exception occurs, GC processing is performed to release a memory area that is no longer needed and is allocated by another application and rearrange the memory area. Furthermore, if an exception occurs in the application development stage, a heap dump file indicating the state of the memory after executing the GC process is not generated. If no exception occurs in the application development stage, a heap dump file is generated. I do. As described above, even when the same OutOfMemory is generated, it is possible to switch whether heap dump files are generated or not according to the determination results of the three conditions. According to the present embodiment, when the three conditions are predetermined determination results (when S104 is YES and S105 and S106 are NO), the application creator uses the measurement tool to determine the maximum amount of memory used by the application. It is determined that this is a case of checking, and a heap dump file is not generated. When the heap dump file is not generated, the entire system is not stopped by the GC process performed before generating the heap dump file, so that the operability of the user (app creator) can be prevented from being lowered. Further, when a heap dump file is not generated, the system load can be reduced because resources (HDD, memory, etc.) of the image forming apparatus 100 are not used for generating the heap dump file of the image forming apparatus 100. Note that the above three conditions are not conditions that indicate whether heap dump files are generated. Therefore, the user (application developer) only performs settings for installing the measurement tool, and does not need to be aware of the switch for generation or not. In addition, there is a condition for determining whether or not the product is under development among the three conditions. As a result, even if a situation that matches the other two conditions is created during product development of the MFP, a heap dump file can be generated, and a fault investigation such as a Java application memory leak can be efficiently performed. it can.

<Modification>
Further, the present invention is not limited to the above embodiment, and various modifications can be made. In the above embodiment, whether or not a heap dump file is generated is determined using three conditions (S104 to S106), and if S104 is YES and S105 and S106 are NO, heap dump file generation is not performed. However, both the determination of whether to perform code signature authentication (S105) and the determination of whether to check the license file (S106) can be changed to settings that meet the conditions when using the measurement tool. Therefore, the conditions of S105 and S106 may be determined based on one of the conditions. In this case, when S104 is YES and S105 is NO, or when S104 is YES and S106 is NO, heap dump file generation may not be performed. Further, the determination may be performed using at least one of the three conditions.

<Second Embodiment>
Hereinafter, a second embodiment of the present invention will be described. In the first embodiment, whether or not a heap dump file is generated when OutOfMemoryError occurs is determined using three conditions, and if a predetermined determination result is not obtained, a heap dump file is generated. However, in addition to these three conditions, another condition may be added.

  With reference to FIG. 9, the switching process in the case of adding another condition will be described. Since basic processing and control are the same as those in the first embodiment, only differences from the first embodiment will be described. The processing described below is realized by reading a program stored in the ROM 103 or the HDD 104 and executing the processing using the RAM 102 as a work area in accordance with an instruction from the CPU 101.

  In the first embodiment, the determination is made based on the three conditions of whether or not a heap dump file is generated when OutOfMemoryError occurs. If the predetermined determination result is not obtained, the heap dump file is generated (S108). However, since the Java application operating on the image forming apparatus 100 uses the same Java memory area, if an OutOfMemoryError occurs in one Java application, there is a high possibility that an OutOfMemoryError will occur in another Java application. In this case, there is a problem that a heap dump file is generated many times for the same reason within a predetermined period.

  Therefore, according to the present embodiment, as shown in FIG. 9, the process of S301 for determining whether or not it is the first OutOfMemoryError within a predetermined period by the heap dump file generation determination unit 308 is added before the process of S108. If the determination result is not the first OutOfMemorError, it is determined that no heap dump file is generated, and the process proceeds to S107. If the determination result is the first time, the process proceeds to S108 as generating a heap dump file. Note that information (fourth information) indicating whether or not it is the first OutOfMemoryError is stored in the HDD 104, and the heap dump file generation execution unit 309 can update the information to that it is not the first time after generating the heap dump file in S112. Moreover, it is desirable to return to the information that it is the first time when a predetermined period elapses. As a result, it is possible to control not to generate a heap dump file in a predetermined period except when the first OutOfMemoryError occurs. The predetermined period may be set in advance in the image forming apparatus 100 or may be set by an operator. The setting information is stored in the HDD 104 in association with the fourth information.

  In the first embodiment, it is determined whether or not the image forming apparatus 100 is developing a product (S104). If it is not under development, it is determined that a heap dump file is generated (S108). However, before the product development of the image forming apparatus 100 is completed, it may be desired to check the maximum memory usage of the created Java application using a product simulator. In this case, since the determination in S104 is always NO, there is a problem that a heap dump file is generated every time OutOfMemoryError occurs.

  Therefore, according to the present embodiment, after S104, the process of S302 in which “the image forming apparatus 100 is a simulator” is determined by the heap dump file generation determination unit 308 is added. If this determination result is not a simulator (in the case of a product), a heap dump file is generated as in the conventional case (S108), and if it is a simulator, the process proceeds to S105. Information regarding whether or not the simulator is used (fifth information) may be stored in the ROM 103 in advance, and the heap dump file generation determination unit 308 may determine this by referring to this value. As a result, even when the MFP is under product development, heap dump files can be prevented from being generated.

  As described above, the image forming apparatus according to the present embodiment can further prevent a useless heap dump file from being generated by adding two conditions (S301 and S302). Note that only one of the two conditions (S301 and S302) may be added.

<Other embodiments>
The present invention supplies a program that realizes one or more functions of the above-described embodiments to a system or apparatus via a network or a storage medium, and one or more processors in a computer of the system or apparatus read and execute the program This process can be realized. It can also be realized by a circuit (for example, ASIC) that realizes one or more functions.

  101: CPU, 102: RAM, 103: ROM, 104: HDD, 202: JavaVM, 203: Application platform, 301: Bytecode execution unit, 302: Class loader management unit, 303: GC execution unit, 304: Memory control unit 305: Heap dump file information generation unit 306: OutOfMemoryError generation unit 307: Application management unit 308: Heap dump file generation determination unit 309: Heap dump file generation execution unit

Claims (14)

An information processing apparatus,
A memory control means for allocating a memory area according to a memory request from an application and generating an exception if the memory area cannot be allocated;
When the exception occurs, execution means for executing a GC process for releasing a memory area that is no longer needed reserved by another application and rearranging the memory area;
When a GC process is executed by the execution unit, a determination unit that determines whether or not the exception has occurred in the application development stage based on information stored in the information processing apparatus;
If the exception occurs in the development stage of the application based on the determination result by the determination unit, the application does not generate a heap dump file indicating the state of the memory after executing the GC process by the execution unit. An information processing apparatus comprising: generating means for generating the heap dump file if the exception does not occur in the development stage. The information stored in the information processing apparatus includes first information indicating whether or not development of the information processing apparatus is completed,
When the first information indicates that the development of the information processing apparatus is completed, the determination unit determines that the exception has occurred in the application development stage, and the development of the information processing apparatus is 2. The information processing apparatus according to claim 1, wherein when the first information indicates that the application has not been completed, it is determined that the exception is not generated in the development stage of the application. The information stored in the information processing apparatus includes first information indicating whether or not development of the information processing apparatus is completed, and whether or not to perform code signature authentication when installing an application in the information processing apparatus Including second information indicating
If the first information indicates that the development of the information processing apparatus has been completed, and the second information indicates that the code signature authentication is not performed, the determination unit determines the application development stage. When the first information indicates that the development of the information processing apparatus has not been completed, or when the second information indicates that the code signature authentication is performed. The information processing apparatus according to claim 1, wherein it is determined that the exception does not occur in the application development stage. The information stored in the information processing apparatus includes first information indicating whether or not development of the information processing apparatus is completed, and whether or not to check a license file of an application that has made the memory request. Including third information to indicate,
In the case where the first information indicates that the development of the information processing apparatus is completed and the third information indicates that the license file is not checked, the determination unit is configured to develop the application. It is determined that the exception has occurred in the stage, and if the first information indicates that the development of the information processing apparatus has not been completed, or the third information indicates that the license file is to be checked The information processing apparatus according to claim 1, wherein the information processing apparatus determines that the exception does not occur in the application development stage. The information stored in the information processing apparatus includes first information indicating whether or not development of the information processing apparatus is completed, and whether or not code signature authentication is performed when an application is installed in the information processing apparatus And third information indicating whether or not to check the license file of the application that has made the memory request,
The determination means indicates that the first information indicates that the development of the information processing apparatus has been completed, and indicates that the second information indicates that the code signature authentication is not performed, and checks the license file. If the first information indicates that the exception has occurred in the application development stage, and the first information indicates that the development of the information processing apparatus has not been completed. If the second information indicates that the code signature authentication is to be performed, or if the third information indicates that the license file is to be checked, it is determined that the exception has not occurred in the application development stage. The information processing apparatus according to claim 1, wherein:   The generation unit generates the heap dump file if the generation of the exception is the first occurrence within a predetermined period when the determination unit determines that the exception is not generated in the application development stage. The information processing apparatus according to claim 1, wherein the information processing apparatus is an information processing apparatus.   When the generation unit generates the heap dump file, the generation unit changes the fourth information indicating whether or not the exception is generated for the first time within a predetermined period to information indicating that the exception is not generated for the first time. The information processing apparatus according to claim 6.   8. The information processing according to claim 7, wherein the generation unit changes the fourth information to information indicating the first occurrence when the predetermined period has elapsed since the first occurrence of the exception. apparatus.   The generation unit generates the heap dump file if the information processing apparatus is not a simulator when the determination unit determines that the exception does not occur in the application development stage. Item 9. The information processing apparatus according to any one of Items 1 to 8.   The first information is changed from information indicating that the development of the information processing apparatus is not completed at the time of shipment of the information processing apparatus to information indicating that the development of the information processing apparatus is completed. The information processing apparatus according to claim 2, wherein the information processing apparatus is an information processing apparatus.   The information processing apparatus according to claim 3, wherein the second information is set by a creator of the application.   The information processing apparatus according to claim 4, wherein the third information is set by a creator of the application. A method for controlling an information processing apparatus,
A memory control means for securing a memory area in accordance with a memory request from an application and generating an exception if the memory area cannot be secured;
An execution step of executing GC processing to release a memory area that is no longer needed and to relocate the memory area when the exception occurs, and when the exception occurs,
A determination step of determining whether or not the exception has occurred in the application development stage based on information stored in the information processing device when GC processing is executed in the execution step; ,
If the exception occurs in the application development stage based on the determination result in the determination step, the generation unit generates a heap dump file indicating the state of the memory after executing the GC processing in the execution step If the exception does not occur in the application development stage, a generation process for generating the heap dump file is executed.   A computer-readable program for causing a computer to execute each step in the method for controlling an information processing apparatus according to claim 13.

Images