JP7564445B2 - MEMORY ALLOCATION DEVICE, MEMORY ALLOCATION PROGRAM, AND MEMORY ALLOCATION METHOD - Google Patents

Description

This case relates to a memory allocation device, a memory allocation program, and a memory allocation method.

When an operating system (hereafter simply referred to as OS) is unable to maintain normal operation, it is known that the OS generates an exception signal and instructs the kernel, the core part of the OS responsible for basic control of the CPU (Central Processing Unit), to execute a core dump process. The core dump process is a process in which the entire contents of the memory space at the time the exception signal occurred are stored as is in a core file.

For example, general-purpose OSs such as UNIX (registered trademark) have a function for constantly monitoring signal events, and when an exception signal occurs, they execute exception processing according to the exception signal. For example, when it is determined that it is difficult to continue operating the OS any further, they execute a core dump process and generate a core file that stores all of the contents of the memory space at that time. The core file generated in this way is used to analyze the cause of the failure (see, for example, Patent Document 1).

JP 2007-172414 A

Some OSs have two types of kernels. For example, Linux (registered trademark) has a system operation kernel (hereinafter referred to as the first kernel) that performs normal control such as job management and memory management, and a dump operation kernel (hereinafter referred to as the second kernel) that performs control when a failure (crash) occurs in the OS (specifically the first kernel). When a failure occurs in the OS, the second kernel executes kdump (kernel crash dump or kernel memory dump) processing and generates a dump file that stores the kernel portion of the memory space contents at the time of the failure.

The amount of memory used by the second kernel when it is running is specified by the operator's prior estimate so that the first kernel does not use it. This amount of memory is allocated in advance as an environment setting by the first kernel when the OS starts up. If the amount of memory allocated for the second kernel's use becomes large, the amount of memory available to the first kernel will decrease, so it is desirable to keep the amount of memory for the second kernel as small as possible.

However, the amount of memory allocated for use by the second kernel varies depending on the hardware and software configuration, making it difficult for workers to estimate an appropriate amount of memory. For this reason, when building a new environment for dump processing or changing the configuration of that environment, workers adjust the amount of memory while checking the actual performance on the actual machine, and then estimate and determine the amount of memory to be allocated for use by the second kernel. However, this work is cumbersome and insufficient because it is not possible to evaluate whether it is appropriate.

Therefore, in one aspect, the objective is to quickly estimate an adaptive amount of memory to be allocated for use by the second kernel.

In one embodiment, the memory allocation device has a first execution unit that executes a first kernel that sets up an environment for acquiring a dump representing memory contents at the time of an OS failure, a second execution unit that executes a second kernel that acquires the dump, an execution instruction unit that instructs the second kernel to acquire the dump during the setting of the acquisition environment, a measurement unit that measures the memory usage of the second kernel while the second kernel is running, and an estimation unit that estimates the memory allocation amount to be assigned to the use of the second kernel based on the measured memory usage.

It is possible to quickly estimate the adaptive amount of memory to allocate for use by the second kernel.

FIG. 1 is a block diagram illustrating a hardware configuration of a server device. FIG. 2 is a block diagram illustrating an example of the functional configuration of the server device. FIG. 3 is a block diagram illustrating the functional configuration of the first kernel and the second kernel. FIG. 4 is a flowchart showing an example of a process executed by the first kernel. FIG. 5 shows an example of a table of areas in the auxiliary storage unit for saving dumps (hereinafter referred to as dump save areas). FIG. 6 is a flowchart showing an example of a process executed by the second kernel. 7A and 7B are flow charts showing an example of a memory acquisition process and a memory release process, respectively. FIG. 8 is a graph showing the transition of the new memory usage. FIG. 9 is a diagram for explaining a comparative example and the first embodiment. FIG. 10 is a flowchart showing another example of the process executed by the first kernel. FIG. 11 is a diagram illustrating the second embodiment.

The following describes the implementation of this invention with reference to the drawings.

FIG. 1 is a block diagram illustrating a hardware configuration of a server device 100. As shown in FIG. 1, the server device 100 as a memory allocation device includes a CPU 100A and a RAM (Random Access Memory) 100B as hardware processors. The server device 100 includes a ROM (Read Only Memory) 100C, a network I/F (interface) 100D, and a HDD (Hard Disk Drive) 100E. Instead of the HDD (Hard Disk Drive) 100E, a SSD (Solid State Drive) may be used. The server device 100 may include at least one of an input I/F 100F, an output I/F 100G, an input/output I/F 100H, and a drive device 100I, as necessary. The CPU 100A to the drive device 100I are connected to each other by an internal bus 100J. In other words, the server device 100 can be realized by a computer. Instead of the CPU 100A, an MPU (Micro Processing Unit) may be used as the hardware processor.

An input device 11 is connected to the input I/F 100F. Examples of the input device 11 include a keyboard, a mouse, and a touch panel. A display device 12 is connected to the output I/F 100G. Examples of the display device 12 include a liquid crystal display. A semiconductor memory 13 is connected to the input/output I/F 100H. Examples of the semiconductor memory 13 include a USB (Universal Serial Bus) memory and a flash memory. The input/output I/F 100H reads the programs and data stored in the semiconductor memory 730. The input I/F 100F and the input/output I/F 100H each include a USB port, for example. The output I/F 100G includes a display port, for example.

A portable recording medium 14 is inserted into the drive device 100I. Examples of the portable recording medium 14 include removable disks such as a CD (Compact Disc)-ROM and a DVD (Digital Versatile Disc). The drive device 100I reads the programs and data recorded on the portable recording medium 14. The network I/F 100D includes, for example, a LAN (Local Area Network) port and a communication circuit.

The CPU 100A temporarily stores in the RAM 100B a program stored in at least one of the ROM 100C, the HDD 100E, and the semiconductor memory 13. The CPU 100A temporarily stores in the RAM 100B a program recorded on the portable recording medium 14. By executing the stored program, the CPU 100A realizes various functions described below and executes various processes described below. The program may correspond to the flowchart described below.

Next, the functional configuration of the server device 100 will be described with reference to FIG. 2.

Figure 2 is a block diagram illustrating an example of the functional configuration of the server device 100. Figure 2 shows the main functions of the server device 100. As shown in Figure 2, the server device 100 includes an auxiliary memory unit 110, a main memory unit 120, and a processing unit 130. The auxiliary memory unit 110 can be realized by the above-mentioned HDD 100E, etc. The main memory unit 120 can be realized by the above-mentioned RAM 100B. The processing unit 130 can be realized by the above-mentioned CPU 100A. Therefore, the auxiliary memory unit 110, the main memory unit 120, and the processing unit 130 are connected to each other.

Here, the auxiliary storage unit 110 stores an OS (not shown). For example, the OS is Linux (registered trademark), but it may be an OS other than Linux (registered trademark). When the power button of the server device 100 is pressed and power is supplied to the server device 100, the processing unit 130 calls up the OS from the auxiliary storage unit 110. Then, the processing unit 130 stores the first kernel 50 included in the called OS in the first kernel memory area 121 of the main storage unit 120 and starts the first kernel 50. That is, the first kernel memory area 121 is a memory area in which the first kernel 50 operates. By starting the first kernel 50, the first kernel 50 performs normal control such as job (or process) management, memory management, operation management, and input/output management, and also executes various processes described later. The first kernel 50 is sometimes called a system kernel.

In addition, by starting the first kernel 50, the first kernel 50 allocates (or reserves) the second kernel memory area 122 in the main memory unit 120, and stores the second kernel 60 included in the OS in the second kernel memory area 122. In other words, the second kernel memory area 122 is the memory area in which the second kernel 60 operates. The second kernel 60 performs control when a failure (abnormality) such as a kernel crash occurs in the OS (specifically, the first kernel 50). The second kernel is sometimes called a dump capture kernel or simply a dump kernel.

To be more specific, when the first kernel 50 detects a logical anomaly in its own processing and determines that it is impossible to continue the processing, it starts the second kernel 60. The second kernel 60 writes a dump file that stores the kernel portion of the memory space contents in the first kernel memory area 121 into the dump save area 111 of the auxiliary storage unit 110. After writing the dump file, the second kernel 60 shuts down or restarts itself.

Next, referring to FIG. 3, an overview of the functions of the first kernel 50 and the second kernel 60 will be described. The functions of the first kernel 50 can be realized by the processing unit 130 working in conjunction with the main memory unit 120 to execute the processing of the first kernel 50. The processing of the second kernel 60 is similar to that of the first kernel 50. Details of the processing of the first kernel 50 and the second kernel 60 will be explained in detail when explaining the operation of the server device 100.

Figure 3 is a block diagram illustrating the functional configuration of the first kernel 50 and the second kernel 60. The first kernel 50 includes a first kernel execution unit 51, a first judgment unit 52, a second judgment unit 53, and an environment construction unit 54 as components. The first kernel 50 also includes an initial setting unit 55, a dump operation unit 56, a checkpoint setting unit 57, and a second kernel execution instruction unit 58 as components. The first kernel execution unit 51 is an example of a first execution unit, the second kernel execution instruction unit 58 is an example of an execution instruction unit, the environment construction unit 54 is an example of an estimation unit, and the checkpoint setting unit 57 is an example of a setting unit.

The second kernel 60 includes as its components a second kernel execution unit 61, a memory usage measurement unit 62, a memory usage registration unit 63, and a first kernel execution instruction unit 64. The second kernel execution unit 61 is an example of a second execution unit, and the memory usage measurement unit 62 is an example of a measurement unit. The first kernel 50 and the second kernel 60 cooperate directly with each other, and also cooperate indirectly via the dump evacuation area 111.

Next, the processing of the first kernel 50 and the second kernel 60 will be described with reference to Figures 4 to 6.

Figure 4 is a flowchart showing an example of processing executed by the first kernel 50. Figure 5 is an example of a dump evacuation area table T1. Figure 6 is a flowchart showing an example of processing executed by the second kernel 60. First, when power is supplied to the server device 100, the first kernel execution unit 51 starts the first kernel 50 (step S1). This causes the initial setting unit 55 to start initial setting of the dump file acquisition environment or collection environment (hereinafter simply referred to as the acquisition environment), and starts setting, for example, the network IP address and the partition of the HDD 100E.

When the first kernel 50 is started, in parallel with the initial setting, the first determination unit 52 determines whether or not the environment for acquiring the dump file has been constructed (step S2). Specifically, the first determination unit 52 accesses the dump save area 111 and determines whether or not the environment for acquiring the dump file has been constructed. Note that the state in which the environment for acquiring the dump file has been constructed indicates a state in which the memory usage for the second kernel 60 has already been set in the first kernel 50.

As shown in FIG. 5, the dump save area 111 manages various information using the dump save area table T1. Specifically, the dump save area table T1 includes information such as the acquired environment state identifier, the second kernel memory usage, the data length, and the first kernel initial setting value. For example, one of three types of identifiers is registered as the acquired environment state identifier. The identifier "0" indicates that the dump file acquisition environment has not yet been constructed (not constructed). The identifier "1" indicates that the dump file acquisition environment is in the process of being constructed (under construction). The identifier "2" indicates that the dump file acquisition environment has already been constructed (constructed). The remaining information will be described later.

The first determination unit 52 accesses the dump save area 111, and if the identifier "0" is assigned to the acquired environment state identifier, for example, it determines that the acquired environment has not been constructed (step S2: NO). In this case, the first determination unit 52 then determines whether the acquired environment of the dump file is being constructed (step S3). Specifically, the first determination unit 52 accesses the dump save area 111 and determines whether the acquired environment of the dump file is being constructed. If the identifier "0" is similarly assigned to the acquired environment state identifier, the first determination unit 52 determines that the acquired environment is not being constructed (step S3: NO). Therefore, the processing of steps S2 and S3 by the first determination unit 52 determines that the acquired environment of the dump file has not been constructed.

If the environment for acquiring the dump file has not been constructed, then the checkpoint setting unit 57 sets a checkpoint (step S4). Specifically, if the environment for acquiring the dump file has not been constructed, the environment construction unit 54 requests the checkpoint setting unit 57 to set a checkpoint. When the checkpoint setting unit 57 is requested to set a checkpoint, it sets all initial setting values (specifically, network addresses, partitions, etc.) that have been set since the first kernel 50 was started up to the present time and the data length of the initial setting values as checkpoints. Then, the checkpoint setting unit 57 requests the dump operation unit 56 to register the set checkpoint. When the dump operation unit 56 is requested to register a checkpoint, it registers the checkpoint in the dump save area 111. As a result, as shown in FIG. 5, the initial setting values as checkpoints and the data length of the initial setting values are registered in the dump save area 111.

When the checkpoint is set, the environment construction unit 54 then rewrites the identifier to "under construction" (step S5). Specifically, the environment construction unit 54 requests the dump operation unit 56 to rewrite the acquired environment state identifier to the identifier "1". When the dump operation unit 56 is requested to rewrite, it deletes the identifier "0" from the acquired environment state identifier and registers the identifier "1" in the dump evacuation area 111. As a result, the acquired environment state identifier in the dump evacuation area table T1 is rewritten to the identifier "1" indicating that construction is in progress, and the state transitions to one in which setting of memory usage for the second kernel 60 begins.

When the identifier is rewritten during construction, the environment construction unit 54 allocates the entire memory capacity in the server device 100 for the operation of the second kernel 60 (step S6). This total memory capacity corresponds to the capacity of the RAM 100B. This makes it possible to avoid interruptions or delays in the operation of the second kernel 60 due to memory shortages. Thereafter, the second kernel execution instruction unit 58 instructs the execution of the second kernel 60 (step S7). Specifically, the second kernel execution instruction unit 58 instructs the second kernel execution unit 61 of the second kernel 60 to execute the second kernel 60. When the second kernel execution instruction unit 58 instructs the execution of the second kernel 60, the first kernel execution unit 51 temporarily terminates the startup of the first kernel even if it is in the middle of initial configuration, and forcibly switches to the execution of the second kernel 60.

When execution of the second kernel 60 is instructed, the second kernel execution unit 61 starts the second kernel 60 as shown in FIG. 6 (step S8). After the second kernel execution unit 61 starts the second kernel 60, the memory usage measurement unit 62 then executes a measurement process (step S9). Details will be described later, but the measurement process is a process that actually measures (measures) the amount of memory used when the second kernel 60 operates and outputs the maximum memory usage. By executing the measurement process, the memory usage measurement unit 62 can identify the maximum memory usage required for use of the second kernel 60.

Once the memory usage has been identified, the memory usage registration unit 63 then registers the memory usage (step S10). Specifically, the memory usage registration unit 63 accesses the dump save area 111 and registers the memory usage. As a result, as shown in FIG. 5, the identified memory usage is registered in the second kernel memory usage of the dump save area table T1. The memory usage registered in the second kernel memory usage is, for example, in units of several hundred megabytes, ranging from 128 megabytes (MB) to approximately 512 megabytes.

When the memory usage is registered, the first kernel execution instruction unit 64 instructs the first kernel 50 to be executed (step S11). Specifically, the first kernel execution instruction unit 64 instructs the first kernel execution unit 51 of the first kernel 50 to execute the first kernel 50. As a result, the process of step S1 shown in FIG. 4 is executed again. When the first kernel execution instruction unit 64 instructs the execution of the first kernel 50, the second kernel execution unit 61 ends the startup of the second kernel.

Returning to FIG. 4, when execution of the first kernel 50 is instructed, the first kernel execution unit 51 starts the first kernel 50 in the process of step S1. Here, in the process of step S5 described above, the acquisition construction state identifier is rewritten to the identifier "1". Therefore, in the process of step S2, the first determination unit 52 determines that the acquisition environment has not been constructed, but in the process of step S3, the first determination unit 52 determines that the acquisition environment is being constructed (step S3: YES). As a result, the dump operation unit 56 acquires various information from the dump save area 111 (step S12). Specifically, the dump operation unit 56 acquires the values of the second kernel memory usage, data length, and first kernel initial setting value.

When the dump operation unit 56 acquires various information, the environment construction unit 54 determines whether the data length is 0 (zero) based on the data length (step S13). If the data length is not 0 (step S13: NO), the first kernel initial setting value exists, so the checkpoint setting unit 57 restores the initial settings based on the first kernel initial setting value (step S14). The restored initial settings become a checkpoint for resuming the initial settings. The environment construction unit 54 continues the initial settings again based on this checkpoint. Note that if the data length is 0 (step S13: YES), the first kernel initial setting value does not exist, so the checkpoint setting unit 57 skips the processing of step S14.

Next, the environment construction unit 54 estimates the memory allocation based on the second kernel memory usage (step S15). For example, the environment construction unit 54 may estimate the second kernel memory usage as the memory allocation as is, or may calculate the memory usage based on the second kernel memory usage and a predetermined calculation formula that calculates a memory usage larger than the second kernel memory usage, and estimate the memory usage as the memory allocation. Simply, to allow for some leeway in memory usage, the memory usage calculated by adding a predetermined memory usage to the second kernel memory usage may be estimated as the memory allocation.

When the environment construction unit 54 estimates the memory allocation amount, it sets the memory allocation amount to the first kernel 50 (step S16). As a result, when the first kernel 50 is started, the first kernel 50 can reserve the second kernel memory area 122 of that memory allocation amount in the main memory unit 120. After the memory allocation amount is set, the environment construction unit 54 then rewrites the identifier to "constructed" (step S17). Specifically, the environment construction unit 54 requests the dump operation unit 56 to rewrite the acquired environment state identifier to the identifier "2". When the dump operation unit 56 is requested to rewrite, it deletes the identifier "1" of the acquired environment state identifier and registers the identifier "2" in the dump evacuation area 111. As a result, the acquired environment state identifier in the dump evacuation area table T1 is rewritten to the identifier "2" indicating "constructed", and the state transitions to a state in which the setting of the memory usage amount for the second kernel 60 has been completed.

When the processing of step S17 is completed, the environment construction unit 54 initializes the dump evacuation area table T1 (step S18). Specifically, the environment construction unit 54 requests the dump operation unit 56 to delete the values of the second kernel memory usage, data length, and first kernel initial setting value. When the dump operation unit 56 receives the deletion request, it deletes the values of the second kernel memory usage, data length, and first kernel initial setting value from the dump evacuation area table T1 of the dump evacuation area 111. As a result, the identifier "2" remains in the acquired environment state identifier of the dump evacuation area table T1, and the second kernel memory usage, data length, and first kernel initial setting value each have no value.

When the processing of step S18 is completed, the environment construction unit 54 continues to start the first kernel 50 (step S19), and the initial setting unit 55 proceeds with the initial setting processing. Then, when the initial setting unit 55 finishes the initial setting, the first kernel 50 ends the processing. Note that, in the processing of step S2 described above, if it is determined that the acquisition environment has been constructed (step S2: YES), the environment construction unit 54 executes step S19. Then, when the initial setting unit 55 finishes the initial setting, the first kernel 50 ends the processing.

Next, the above-mentioned measurement process will be explained with reference to Figures 7(a) and (b) and Figure 8.

Figure 7(a) is a flowchart showing an example of memory acquisition processing. Figure 7(b) is a flowchart showing an example of memory release processing. Figure 8 is a graph showing the progress of new memory usage. The measurement processing described above includes memory acquisition processing and memory release processing. First, when the second kernel 60 starts up, as shown in Figure 7(a), the memory usage measurement unit 62 acquires memory (step S31). That is, the memory usage measurement unit 62 acquires the amount of memory to be used for the operation of the second kernel 60. This amount corresponds to the amount set by the program requesting memory acquisition.

Next, the memory usage measurement unit 62 calculates a new memory usage by adding the acquired memory amount to the current memory usage amount (step S32). The initial value of the current memory usage amount is 0 (zero). The acquired memory amount is the amount of memory acquired by the memory usage measurement unit 62. Therefore, as shown in FIG. 8, a new memory amount according to the processing amount of the second kernel 60 is acquired until time t1, at which time the new memory usage amount increases steadily with the passage of time.

Next, the memory usage measurement unit 62 determines whether the new memory usage is greater than the maximum memory usage (step S33). If the new memory usage is greater than the maximum memory usage (step S33: YES), the maximum memory usage is set to the new memory usage (step S34). That is, the maximum memory usage is updated to the new memory usage. This makes it possible to identify the maximum memory usage up to time t1, as shown in FIG. 8. Note that if the new memory usage is equal to or less than the maximum memory usage (step S33: NO), the processing of step S34 is skipped. Therefore, the maximum memory usage is maintained without being updated.

On the other hand, when the execution of part of the processing of the second kernel 60 is completed, the memory usage measurement unit 62 releases the memory as shown in FIG. 7(b) (step S41). That is, the memory usage measurement unit 62 releases the amount of memory that was used for the operation of part of the second kernel 60. This amount corresponds to the amount set by the program requesting the memory release.

Next, the memory usage measurement unit 62 calculates a new memory usage by subtracting the memory release amount from the current memory usage (step S42). The memory release amount is the amount of memory released by the memory usage measurement unit 62. In this way, memory is released when execution of part of the processing of the second kernel 60 is completed. As a result, as shown in FIG. 8, for example, after time t1, the new memory usage starts to decline.

In this way, the memory usage measurement unit 62 measures the maximum memory usage by executing the memory acquisition process and the memory release process independently or in parallel depending on the processing status of the second kernel 60. After the memory usage measurement unit 62 finishes measuring the maximum memory usage, since the new memory usage is expressed as a percentage, it converts the new memory usage into memory usage in megabytes based on, for example, the memory capacity, the new memory usage, and a predetermined conversion formula that converts percentages into megabytes, and outputs the converted new memory usage.

Next, the first embodiment will be described in comparison with a comparative example with reference to FIG.

Figure 9 is a diagram for explaining a comparative example and the first embodiment. First, in the case of the comparative example shown in the upper part of Figure 9, the first kernel 50 sets the memory usage for the second kernel 60 to the memory amount specified the first time by the worker. When the memory usage for the second kernel 60 is set, the second kernel 60 executes the kdump process and attempts to obtain a dump file. At this time, if obtaining the dump file fails, the set memory usage is insufficient, and the worker specifies a memory amount larger than the memory amount specified the first time and attempts to reconfigure the first kernel 50.

On the other hand, if the set memory usage is large enough so that it does not interfere with the operation of the second kernel 60, the setting may be completed. However, if the specified memory amount is larger than necessary compared to the actual memory usage of the second kernel 60, there is waste of memory amount, and it is unclear whether the optimal memory usage amount has been set. In some cases, this may interfere with the operation of the first kernel 50. For this reason, the worker checks the actual machine, and if it is determined that the memory usage amount is not optimal, the worker specifies the memory amount again. If the worker obtains the same results in the second operation as in the first operation, the worker performs the operation a third time, and thereafter repeats the operation until the worker determines that the memory usage amount is optimal. Thus, in the comparative example, the operation was complicated and it was difficult to evaluate whether it was appropriate.

However, according to the first embodiment shown in the lower part of Figure 9, the first kernel 50 starts the initial setting even if the worker does not specify the memory amount. When the first kernel 50 sets a checkpoint, it starts the second kernel 60 even if the initial setting is in the middle of being performed, and temporarily ends the processing of the first kernel 50. The second kernel 60 executes the kdump process, measures the maximum memory usage actually used by the second kernel 60 during the kdump process, and registers it in the dump save area 111. When the kdump process ends, the second kernel 60 starts the first kernel 50.

When the first kernel 50 starts up, it estimates the memory allocation for the second kernel 60 based on the memory usage registered in the dump save area 111, and resumes the initial settings from the checkpoint. In this way, even if the worker does not specify the memory amount, the first kernel 50 estimates the memory allocation based on the maximum memory usage actually used by the second kernel 60, and sets the estimated memory allocation for itself. Therefore, the worker can estimate an adaptive memory usage in a short time without performing complicated work.

As described above, according to the first embodiment, the server device 100 includes a first kernel execution unit 51, a second kernel execution unit 61, a memory usage measurement unit 62, and an environment construction unit 54. The first kernel execution unit 51 executes the first kernel 50, which sets the environment for acquiring a dump file that represents memory contents at the time of an OS failure. The second kernel execution unit 61 executes the second kernel 60, which acquires a dump file in the middle of setting the environment for acquiring the dump file. The memory usage measurement unit 62 measures the memory usage of the second kernel 60 while the second kernel 60 is running. The environment construction unit 54 estimates the memory allocation amount to be allocated to the use of the second kernel 60 based on the memory usage measured by the memory usage measurement unit 62. This makes it possible to estimate an adaptive memory amount to be allocated to the use of the second kernel 60 in a short time.

Here, it is also conceivable that the adaptive memory amount to be allocated for use by the second kernel 60 can be estimated based on, for example, the amount of memory required to start the first kernel 50. However, while the first kernel 50 starts up using a swap area, the second kernel 60 starts up without using a swap area. For this reason, the amount of memory required to start the first kernel 50 tends to be smaller than the amount of memory required to start the second kernel 60. Therefore, even if the amount of memory required to start the first kernel 50 is used, it is not necessarily possible to estimate the adaptive memory amount to be allocated for use by the second kernel 60.

It is also conceivable to calculate the amount of memory used by each piece of software (e.g., drivers, middleware, etc.) owned by the second kernel 60, and determine the memory usage to be allocated to the second kernel 60 by calculating the sum of the calculated memory amounts. However, the individual pieces of software owned by the second kernel 60 are diverse, and it is extremely difficult to investigate the memory usage of all the software in advance. In addition, since the amount of memory used varies depending on the hardware environment in which the second kernel 60 operates, the estimation formula for estimating the memory usage may become complicated. However, according to the first embodiment and the second embodiment described later, the operator can estimate an adaptive amount of memory to be allocated to the second kernel 60 in a short time without having to perform cumbersome verification of the memory amount.

Second Embodiment
Next, the second embodiment of the present invention will be described with reference to FIG. 10 and FIG. 11. FIG. 10 is a flowchart showing another example of the process executed by the first kernel 50. As shown in FIG. 10, the second determination unit 53 of the first kernel 50 waits until it receives an instruction to change the configuration (step S51: NO). For example, the second determination unit 53 waits until it detects an instruction to change the memory allocation amount from the worker. When the second determination unit 53 determines that an instruction to change the configuration has been received (step S51: YES), the environment construction unit 54 rewrites the identifier to "under construction" (step S52). In the case of a configuration change, since the identifier "2" indicating "constructed" is registered in the acquired environment state identifier of the dump evacuation area table T1, when the dump operation unit 56 is requested to rewrite, it deletes the identifier "2" of the acquired environment state identifier and registers the identifier "1" in the dump evacuation area 111.

When the identifier is rewritten during construction, the environment construction unit 54 allocates the entire memory capacity in the server device 100 for the operation of the second kernel 60 (step S53). When the processing of step S53 is completed, the second kernel execution instruction unit 58 instructs the execution of the second kernel 60 (step S54) and ends the processing. Note that the processing executed by the second kernel is similar to that of the first embodiment described with reference to FIG. 6, and therefore a detailed description thereof will be omitted. In addition, the processing after the second kernel has finished executing the processing is similar to that of the first embodiment described with reference to FIG. 4, and therefore a detailed description thereof will be omitted. In the second embodiment, the initial setting value is not registered in the dump save area 111, so the environment construction unit 54 determines that the data length is 0 in the processing of step S13 in FIG. 4.

Figure 11 is a diagram illustrating the second embodiment. According to the second embodiment, the first kernel 50 allocates the entire memory amount for the operation of the second kernel 60 if there is an instruction to change the configuration, even if the memory amount is not specified by the worker. The first kernel 50 then starts the second kernel 60 and ends the processing of the first kernel 50. The second kernel 60 executes the kdump process, measures the maximum memory usage actually used by the second kernel 60 during the kdump process, and registers it in the dump save area 111. The second kernel 60 starts the first kernel 50 when the dump process ends.

When the first kernel 50 starts, the first kernel 50 estimates the memory allocation for the second kernel 60 based on the memory usage registered in the dump save area 111. In this way, even if the worker does not specify the memory amount, the first kernel 50 estimates the memory allocation based on the maximum memory usage actually used by the second kernel 60. In this way, even in the second embodiment, the worker can estimate an adaptive memory usage in a short time without performing complicated work.

The above describes in detail preferred embodiments of the present invention, but the present invention is not limited to these specific embodiments, and various modifications and variations are possible within the scope of the gist of the present invention as described in the claims.

In addition, the following supplementary notes are provided in relation to the above description.
(Supplementary Note 1) A memory allocation device having a first execution unit that executes a first kernel that sets up an environment for acquiring a dump representing memory contents in the event of an OS failure, a second execution unit that executes a second kernel that acquires the dump, an execution instruction unit that instructs the second kernel to acquire the dump while the acquisition environment is being set, a measurement unit that measures memory usage of the second kernel while the second kernel is running, and an estimation unit that estimates a memory allocation amount to be allocated to use by the second kernel based on the measured memory usage.
(Supplementary Note 2) A memory allocation device as described in Supplementary Note 1, further comprising a setting unit that sets the time when the setting of the acquisition environment is resumed, and the estimation unit resumes the setting of the acquisition environment from the time when the setting is resumed.
(Appendix 3) The memory allocation device described in Appendix 1 or 2, characterized in that the second execution unit executes the second kernel after the entire capacity of the main memory unit of the memory allocation device has been allocated for use by the second kernel by the first kernel.
(Supplementary Note 4) A memory allocation device as described in any one of Supplementary Notes 1 to 3, characterized in that the dump represents a kernel portion of the memory contents.
(Additional Note 5) A memory allocation program for causing a computer to execute a process of executing a first kernel that sets up an environment for acquiring a dump representing memory contents in the event of an OS failure, instructing a second kernel that acquires the dump to acquire the dump during the setting of the acquisition environment, executing the second kernel that acquires the dump in response to the instruction, measuring memory usage of the second kernel while the second kernel is running, and estimating a memory allocation amount to be allocated to use by the second kernel based on the measured memory usage.
(Appendix 6) A memory allocation program as described in Appendix 5, characterized in that it includes a process of setting the time when the setting of the acquisition environment is resumed, and the process of estimating the memory allocation amount resumes the setting of the acquisition environment from the time when the setting is resumed.
(Appendix 7) The memory allocation program described in Appendix 5 or 6, characterized in that the process of executing the second kernel executes the second kernel after the entire capacity of the main memory unit of the computer has been allocated by the first kernel for use by the second kernel.
(Appendix 8) A memory allocation program according to any one of Appendices 5 to 7, characterized in that the dump represents a kernel portion of the memory contents.
(Supplementary Note 9) A memory allocation method in which a computer executes a process of executing a first kernel that sets up an environment for acquiring a dump representing memory contents in the event of an OS failure, instructing a second kernel that acquires the dump to acquire the dump during the setting of the acquisition environment, executing the second kernel that acquires the dump in response to the instruction, measuring memory usage of the second kernel while the second kernel is running, and estimating a memory allocation amount to be allocated to use by the second kernel based on the measured memory usage.

50 First kernel 51 First kernel execution unit (first execution unit)
54. Environment Construction Department (Estimation Department)
57 Checkpoint setting unit (setting unit)
58 Second kernel execution instruction unit (execution instruction unit)
60 Second kernel 61 Second kernel execution unit (second execution unit)
62 Memory usage measurement unit (measurement unit)
Reference Signs List 100 Server device 110 Auxiliary storage unit 111 Dump save area 120 Main storage unit 130 Processing unit

Claims (5)

a first execution unit that executes a first kernel that sets an environment for acquiring a dump representing memory contents when an OS (operating system) fails;
a second execution unit that executes a second kernel that acquires the dump;
an execution instruction unit that instructs the second kernel to acquire the dump during the setting of the acquisition environment;
a measurement unit that measures a memory usage of the second kernel while the second kernel is running;
an estimation unit that estimates a memory allocation to be allocated to the second kernel based on the measured memory usage;
A memory allocation apparatus having: A setting unit that sets a time when the acquisition environment is restarted,
The estimation unit resumes the setting of the acquisition environment from the time of the resumption of the setting.
2. The memory allocation apparatus of claim 1. the second execution unit executes the second kernel after the first kernel has allocated an entire capacity of a main memory unit included in the memory allocation device to be used by the second kernel.
3. The memory allocation device according to claim 1 or 2. Executing a first kernel that sets up an environment for acquiring a dump representing memory contents in the event of an OS (operating system) failure;
instructing a second kernel that acquires the dump to acquire the dump during the setting of the acquisition environment;
In response to the instruction, execute a second kernel that obtains the dump;
measuring memory usage of the second kernel while the second kernel is running;
estimating a memory allocation to be allocated for use by the second kernel based on the measured memory usage;
A memory allocation program that allows a computer to execute a process. Executing a first kernel that sets up an environment for acquiring a dump representing memory contents in the event of an OS (operating system) failure;
instructing a second kernel that acquires the dump to acquire the dump during the setting of the acquisition environment;
In response to the instruction, execute a second kernel that obtains the dump;
measuring memory usage of the second kernel while the second kernel is running;
estimating a memory allocation to be allocated for use by the second kernel based on the measured memory usage;
A method of allocating memory for a computer to carry out operations.

Images