WO2016195225A1

WO2016195225A1 - Mobile device to which dvfs technique for gpgpu application is applied

Info

Publication number: WO2016195225A1
Application number: PCT/KR2016/003450
Authority: WO
Inventors: 김영준; 김성기
Original assignee: 이화여자대학교 산학협력단
Priority date: 2015-05-29
Filing date: 2016-04-04
Publication date: 2016-12-08

Abstract

A mobile device for a GPGPU application is provided. The mobile device enables: a graphic section for performing only a graphic operation and a GPGPU section for performing a graphic operation or a computing operation to be divided such that respective dynamic frequencies can be variably set, in an interval-based DVFS technique; a weighted value to be variably defined in a threshold value for changing a dynamic frequency value on the basis of a previous use thereof; an interval gap to be adaptively changed according to an application use time; and a multilevel dynamic frequency value to be preset so as to variably adjust a change in size of an increase or a decrease of the dynamic frequency value at once, thereby having results of high performance and energy consumption efficiency compared with a conventional DVFS technique.

Description

Mobile Devices with DVFS Techniques for GPGPU Applications

It relates to mobile devices, and more specifically to mobile devices to which DVFS techniques for GPGPU applications are applied.

GPU (Graphics Processing Units) is a device for processing a large amount of graphics data at high speed. With the development of high resolution display devices, GPUs with high hardware specifications have been developed. As a result, the GPU can handle calculations of applications that the CPU has traditionally handled, and performing general computing tasks is called a general purpose computation on graphics processing unit (GPGPU).

On the other hand, mobile devices have a fundamental problem with the efficiency of energy consumption due to the limited nature of the battery environment, so a variety of software techniques for energy-efficient GPGPU application execution on mobile devices with GPUs are introduced. Voltage and Frequency Scaling) is one of them. In detail, the interval-based DVFS technique predicts the expected usage amount at each interval and adjusts the dynamic frequency by the required prediction usage amount. However, there is a limitation in accurately predicting the usage of real applications, which does not reflect the characteristics of GPGPU applications different from graphic applications.

According to one side, the section determination unit for determining whether to call the first kernel program operating in accordance with the execution of the GPGPU application of one or more kernel programs; And a frequency setting unit configured to set a first dynamic frequency when the graphic application is executed during the first time interval, and set a second dynamic frequency when the GPGPU application is executed.

In one embodiment, the kernel program is an OpenCL kernel, and the first kernel program may include a clEnqueue as a prefix.

In an embodiment, the frequency setting unit may set the second dynamic frequency to a preset maximum frequency value, wherein the maximum dynamic frequency value is preset to a plurality of step values and is based on past usage of the executed GPGPU application. The second dynamic frequency value may be updated based on the nearest value among the plurality of steps. In one embodiment, the threshold value reflecting the weight of the GPGPU application during the first time interval is set to update the second dynamic frequency value based on the threshold value.

In one embodiment, the frequency setting unit may set the dynamic frequency value determined according to the usage amount predicted based on the past usage amount of the graphic application as the first dynamic frequency value. In an example embodiment, a threshold value reflecting a weight based on a time at which a graphic application is executed during the first time interval may be set to update a first dynamic frequency value based on the threshold value.

In an embodiment, the interval of the first time interval may be updated based on the execution time of the past application, and the interval of the first time interval may be updated based on a standard deviation value with respect to the execution time of the past application. Can be.

According to another aspect, a program stored in a computer-readable recording medium, the computing device to cause the GPU to operate in accordance with the dynamic frequency value, the call of the first kernel program of the one or more kernel programs operated in accordance with the execution of the GPGPU application An instruction set for determining whether or not; And a command set for setting a first dynamic frequency when the graphic application is executed during the first time interval and for setting a second dynamic frequency when the GPGPU application is executed.

1 is a block diagram of a mobile device according to an embodiment.

2 is a graph showing GPU utilization and dynamic frequency values for the number of DVFS events.

3 is a flowchart illustrating a process of setting a dynamic frequency in a mobile device according to an embodiment.

4 is a flowchart illustrating a process of setting a first dynamic frequency in a mobile device according to an embodiment.

5 is an algorithm for setting a DVFS event based dynamic frequency according to another embodiment.

FIG. 6 is a graph illustrating energy efficiency according to an embodiment of a method for setting a dynamic frequency for eight mobile applications. Referring to FIG.

Hereinafter, embodiments will be described in detail with reference to the accompanying drawings. However, the scope of the present invention is not limited or limited by these embodiments. Like reference numerals in the drawings denote like elements.

The terminology used in the following description has been chosen to be generally universal in the art to which it relates, although other terms may exist depending on the development and / or change in technology, conventions, and preferences of those skilled in the art. Therefore, the terms used in the following description should not be understood as limiting the technical idea, but should be understood as exemplary terms for describing the embodiments.

In addition, in certain cases, there is a term arbitrarily selected by the applicant, and in this case, the meaning thereof will be described in detail in the corresponding description. Therefore, the terms used in the following description should be understood based on the meanings of the terms and the contents throughout the specification, rather than simply the names of the terms.

1 is a block diagram of a mobile device according to an embodiment. The mobile device 100 includes a section determination unit 110 and a frequency setting unit 120, and whether the graphics application execution section (hereinafter referred to as "graphic section") by the section determination unit 110, GPGPU application execution It may be determined whether the interval (hereinafter referred to as "GPGPU interval"), and the frequency setting unit 120 sets the first dynamic frequency or the second dynamic frequency according to the determination result.

Mobile devices have a limited battery environment because of their portability. Thus, in order to use the battery for a relatively long time, the mobile device has a fundamental problem of reducing energy consumption while providing maximum performance. There are various techniques to achieve this technical purpose, and dynamic voltage and frequency scaling (DVFS) is one of them. Equation 1 below is an expression representing the correlation between energy, voltage, frequency and the like.

In Equation 1, E is energy consumption, P is power consumption, c is a constant value according to the CPU or GPU in the mobile device, F is the operating frequency, V is the required voltage according to the operating frequency, t is the value of F and V It represents the time interval while being maintained.

The voltage V is not directly proportional to the frequency F value, but as the frequency value increases, the required voltage value also increases for stable device operation. Therefore, as the frequency is increased, the power and energy consumed are also significantly increased, so it can be seen that it is necessary to efficiently adjust the frequency in order to minimize the energy consumed.

The interval-based DVFS technique defines a constant time interval as an interval, and sets the dynamic frequency value appropriately by predicting GPU usage for the next interval for each interval.

FIG. 2 is a graph illustrating GPU usage and dynamic frequency values for DVFS event numbers, and specifically, an example graph of measuring GPU usage and dynamic frequency values for DVFS event numbers according to an existing interval-based DVFS technique.

In the graph measurement environment, the number of intervals n is 1, and the GPU utilization and dynamic frequency values are measured for 30 DVFS events while running the SmallptGPU application on Android XU 3 based on the interval-based DVFS technique. . The interval-based DVFS technique applied to FIG. 2 may be represented by Equation 2 below.

In Equation 2, F _i represents the current dynamic frequency value, and U _i represents the predicted usage amount for the next interval. The minimum threshold H _D is set to 60 and the maximum threshold H _U is set to 85 for dynamic frequency setting. Therefore, in the experiment of FIG. 2, when the predicted usage amount U _i is smaller than the minimum threshold value H _D , the next dynamic frequency value F _i ₊₁ is set to F _i ^k ⁺ ¹ , which is one greater than the current dynamic frequency value. When the predicted usage amount U _i is larger than the maximum threshold value H _U , the next dynamic frequency value F _i ₊₁ is set to F _i ^k ⁻ ¹ , which is one smaller than the current dynamic frequency value.

As a result, as a result of measuring the GPU usage for each interval, as shown in FIG. 2, the usage amount is not maintained at a constant value but has various values according to the running application, and the usage amount is repeatedly increased or decreased. have. Accordingly, interval-based DVFS analyzes past usage to predict usage for the next interval, so if the past usage is high, the dynamic frequency value can be increased in the next interval. The dynamic frequency value can be reduced. Therefore, in FIG. 2, it can be seen that the dynamic frequency value indicated by the dotted line increases or decreases in time with respect to the utilization curve indicated by the solid line. It is hard to say that a dynamic frequency value has been set. In addition, the GPU usage shows the result of the minimum 30% usage to the maximum 100% usage, but the dynamic frequency value can be seen that the value changes only from the minimum 30% to the maximum 50%. This also shows that the size of the dynamic frequency value does not change actively according to the GPU usage.

These results indicate that the existing interval-based DVFS technique has a limitation in utilization prediction and does not actively adjust the dynamic frequency value. Therefore, in the mobile device 100 according to an embodiment, the interval-based DVFS technique is applied, and the dynamic frequency is divided into a graphic section (graphic application execution section) and a GPGPU section (GPGPU application execution section) to reflect the characteristics of the GPGPU application. It is possible to change the setting and to actively set the dynamic frequency value.

1, the interval determination unit 110 may determine whether the first kernel program operated according to the execution of the GPGPU application among the one or more kernel programs is called. Operating systems (eg, Android, etc.) applied to mobile devices can utilize multiple devices through OpenCL. OpenCL is a platform-independent programming framework that can utilize GPUs and digital processors. Specifically, the GPU can be controlled using the platform model and programming model of OpenCL. The GPGPU interval is characterized by being executed when a function is invoked with a prefix of clEnqueue- in OpenCL. For example, the clEnqueueNDRangeKernel, clEnqueueTask, and clEnqueueNativeKernel functions. The interval determination unit 110 may determine that the GPGPU application is executed when a function including clEnqueue- as a prefix of the OpenCL kernel is called. On the other hand, the interval determination unit 110 may determine that the graphic application is executed when the function including the prefix of clEnqueue- in the OpenCL kernel is terminated or is not called from the beginning.

In one embodiment, specifying the GPGPU section by the section determination unit 110, in addition to the graphic task in the GPGPU section, since general computing tasks are executed together, unlike the graphic section performing only the graphic task, the dynamic frequency setting may be different. Because there is a need.

The frequency setting unit 120 may set a first dynamic frequency when the graphic application is executed during the first time interval, and set a second dynamic frequency when the GPGPU application is executed. The first time interval may refer to each interval in the interval based DVFS technique. Therefore, the interval appropriately selected by the operator may be the first time interval. The first dynamic frequency and the second dynamic frequency mean different dynamic frequencies, but may be set to the same value in some cases. Accordingly, the frequency setting unit 120 may adaptively set the dynamic frequency to different values according to the determination result of the section determination unit 110.

In one embodiment, the frequency setting unit 120 may set the second dynamic frequency to the maximum dynamic frequency value preset for the GPGPU application execution interval. Specifically, since the corresponding kernel program may know what the corresponding GPGPU application is, the maximum dynamic frequency value may be preset in a table based on the GPU usage required for each GPGPU application. In this case, the setting of the dynamic frequency value based on the maximum value is because, unlike the graphic section that performs only the graphic work, the GPGPU section includes computing work and thus requires more power and energy than performing the graphic work only. However, since the required maximum dynamic frequency value may vary for each GPGPU application, the implementer may preset the maximum dynamic frequency value according to the type of GPGPU application that may be executed in the mobile device.

In one embodiment, the maximum dynamic frequency value for the second dynamic frequency setting for the GPGPU application execution interval may be defined as a plurality of step values rather than a constant value. In particular, the second dynamic frequency value may be updated to the nearest value among the plurality of steps based on the past usage of the currently executed GPGPU application. For example, in FIG. 2, the dynamic frequency value may be set only between a minimum of 30% and a maximum of 50%. However, the frequency setting unit 120 may have a dynamic frequency value as a plurality of step values as shown in Table 1 below. You can set this to select the closest value based on past usage of the GPGPU application.

Equation 3 below represents a multi-level frequency setting by an equation.

In Equation 3, F _i is a past dynamic frequency value for the i interval interval, f _j is one of the available dynamic frequency values. When the predicted usage amount U _i is larger than the maximum threshold value H _U , the next dynamic frequency value F _i ₊₁ may be set as the smallest value of f _j available. When the predicted usage U _i is smaller than the minimum threshold H _D , the next dynamic frequency value F _i ₊₁ may be set as the largest value of f _j available.

In relation to the threshold value, the mobile device 100 according to an embodiment may use a threshold value in which weights of respective execution sections are reflected.

The frequency setting unit 120 may set a first dynamic frequency value or a second dynamic frequency value. The threshold setting unit 120 may set a threshold value reflecting a weight according to the time that the graphic application is executed during the first time interval, and based on the threshold value. It is possible to update the first dynamic frequency value with. In addition, a threshold value reflecting a weight based on a time when the GPGPU application is executed during the first time interval may be set, and the second dynamic frequency value may be updated based on the threshold value. These thresholds are defined in the graphics application execution section that executes only one graphics task (or minimum threshold-maximum threshold set), and in the GPGPU application execution section that also performs computer tasks. This is because the characteristics of each execution section cannot be properly reflected. Equation 4 below is a formula showing that the threshold value H is divided into a normal interval and a GPGPU interval for each interval interval.

In Equation 4, H represents a new threshold value, H _g is a threshold value for the graphics section, which is a graphics application execution section, and H _c is a threshold value for the GPGPU application execution section. T _i represents a time interval of the i-th interval interval, g _i represents a time interval for performing a graphics task, c _i represents a time interval for performing a computing task.

By weighting the threshold value for the normal interval according to the time when the graphic operation is performed, and by weighting the threshold value for the GPGPU interval according to the time during which the computing operation is performed, a different weight value can be defined and used for each interval. have.

In one embodiment, the DVFS may define the same time interval and use the interval. Alternatively, the DVFS may be defined differently by adaptively adjusting the interval interval according to the usage pattern. In detail, the frequency setting unit 120 may update the first time interval, that is, the interval of the interval, based on the execution time of the past application. If the same application is running, there is a high probability that the dynamic frequency values will be set equal. On the other hand, when two or more applications are executed within one interval, the dynamic frequency setting is performed only once, and thus the frequency value required for the application cannot be set properly.

In the above embodiment, the interval may be updated using a standard deviation value with respect to the execution time of the past application. This is represented by the following equation (5).

In Equation 5, T _i denotes the i-th interval time interval, T denotes an interval time interval set as a default value, σ is a value for calculating a standard deviation for every DVFS event, and k is a constant value.

3 is a flowchart illustrating a process of setting a dynamic frequency in a mobile device according to an embodiment. The dynamic frequency setting process of FIG. 2 may be repeated for each interval section. When the specific interval starts, the interval determination unit 110 may determine whether the first kernel program is called (step 301). When the first kernel program is called (step 301-example), the frequency setting unit 120 may determine that the GPGPU application is executed, and set the second dynamic frequency value as the dynamic frequency value for the next interval (step 302). . On the contrary, when the first kernel program is not called (step 301-no), the frequency setting unit 120 may determine that the graphic application is executed and set the first dynamic frequency value as the dynamic frequency value for the next interval (303). step).

4 is a flowchart illustrating a process of setting a first dynamic frequency in a mobile device according to an embodiment. According to an embodiment, the frequency setting unit 120 may set the first dynamic frequency value by using the dynamic frequency value determined according to the usage amount predicted based on the past usage amount of the graphic application. In this case, in order to adaptively adjust the first dynamic frequency, the predicted usage amount may be determined using two threshold values. If the predicted usage is larger than the maximum threshold, the currently set dynamic frequency value may be increased. On the contrary, if the predicted usage is smaller than the minimum threshold, the currently set dynamic frequency value may be decreased. If the predicted usage amount is greater than or equal to the minimum threshold and less than or equal to the maximum threshold, the current dynamic frequency value may be maintained as it is.

Referring to FIG. 4, when it is determined that the graphic application is executed by the interval determination unit 110, the frequency setting unit 120 may perform the process of FIG. 4 to set the first dynamic frequency value. In operation 401, the GPU usage may be predicted for the next time interval, that is, the next interval. Historical GPU usage may be used as a basis for prediction, and more specifically, prediction usage may be determined by referring to the past GPU usage of the type of graphics application currently executed. When the usage is predicted, the predicted usage is compared with the maximum threshold (step 402), and when the predicted usage is greater than the maximum threshold (step 402-yes), the currently set dynamic frequency value is increased in a situation where a high frequency is required for the next interval. In operation 403, On the other hand, if the predicted usage is less than or equal to the maximum threshold (step 402-no), the predicted usage is compared with the minimum threshold (step 404). When the predicted usage amount is smaller than the minimum threshold (step 404-example), the currently set dynamic frequency value can be decreased in a situation where the graphic work can be sufficiently performed at a low frequency in the next interval (step 405. Then, the prediction is next). If the usage is greater or less than the minimum threshold (step 404-no), the current dynamic frequency value can be maintained in a situation where the current GPU usage and the predicted usage are similar.

5 is an algorithm for setting a DVFS event based dynamic frequency according to another embodiment. In another embodiment, the interval-based DVFS can be implemented in the form of a computer program since only the software can be modified to improve energy consumption. 5 shows an algorithm for another embodiment, which may be implemented as a function of a computer program. First, the function HANDLE_DVFS_EVENT sets a weighted threshold for the case where the computing task is executed (the execution interval of the GPGPU application-which can be determined by the interval determination unit described in one embodiment) (3-4 lines). The process of adaptively adjusting interval intervals according to past use (6-8 lines) and setting dynamic frequency values to predefined multi-level dynamic frequency values to actively adjust dynamic frequency values (10-33). lines). The algorithm of FIG. 5 is an overview of components included in another embodiment, and may be embodied in other ways according to actual computer programming.

FIG. 6 is a graph illustrating energy efficiency according to an embodiment of a method for setting a dynamic frequency for eight mobile applications. Referring to FIG. In the above embodiments, it is an example of how the efficiency of energy consumption is improved for each configuration and combinations thereof in which the DVFS technique is improved in various ways. First, Table 2 below shows the results of the performance and energy efficiency of each component (or feature) of the above-described embodiments when the performance and energy efficiency of the existing DVFS technique are regarded as 1.

In one embodiment, the DPI indicates the performance of the DVFS technique using a configuration in which a dynamic frequency setting is divided by dividing the graphics section into a graphics section in which the graphics application is executed and the GPGPU section in which the GPGPU application is executed. Next, WT improves on the DVFS technique with a single threshold, which is based on the DVFS technique with a configuration that uses a threshold that reflects the weight of the graphics operation or the computing time according to the past use. Performance. The AIA improves the DVFS technique using the same interval as the interval, and in one embodiment, represents the performance of the DVFS technique with the configuration that updates the time interval of the interval interval adaptively based on the standard deviation value according to the past use. . As shown in FIG. 2, MFA improves on the existing DVFS technique that changes a dynamic frequency using a single set of thresholds, and defines a multi-level dynamic frequency value to actively change the dynamic frequency value. Performance. GPGPU-Perf shows the performance of the DVFS technique to which the algorithm, that is, DPI, WT, AIA, and MFA configuration are applied, according to another embodiment described with reference to FIG. 5.

Looking at the results of Table 2, it can be seen that the performance is improved or the energy efficiency is increased according to each configuration described above in the embodiments. In particular, the GPGPU-Pref showed a 2x performance improvement, but the energy consumption was increased by 151%. Figure 6 shows the results of Table 2 in more detail, applying the terms of Table 2 to the eight mobile applications of SmallptGPU, myocyte, bfs, cfd, gaussian_elim, lud, nw, and pathfinder that are typically used in mobile devices. Bar graph showing performance and energy consumption efficiency improvements. When the value of the performance and energy consumption efficiency of the conventional DVFS scheme is based on 1, it can be seen from FIG. 6 that the performance and energy consumption efficiency of each mobile application are generally higher than 1. Although there is a variation in each mobile application, it is possible to confirm the effect of the above-described embodiments in the mobile device by having a value higher than 1 (line bold horizontally in FIG. 6) as a whole.

The apparatus described above may be implemented as a hardware component, a software component, and / or a combination of hardware components and software components. For example, the devices and components described in the embodiments are, for example, processors, controllers, arithmetic logic units (ALUs), digital signal processors, microcomputers, field programmable gate arrays (FPGAs). Can be implemented using one or more general purpose or special purpose computers, such as a programmable logic unit (PLU), a microprocessor, or any other device capable of executing and responding to instructions. The processing device may execute an operating system (OS) and one or more software applications running on the operating system. The processing device may also access, store, manipulate, process, and generate data in response to the execution of the software. For convenience of explanation, one processing device may be described as being used, but one of ordinary skill in the art will appreciate that the processing device includes a plurality of processing elements and / or a plurality of types of processing elements. It can be seen that it may include. For example, the processing device may include a plurality of processors or one processor and one controller. In addition, other processing configurations are possible, such as parallel processors.

The software may include a computer program, code, instructions, or a combination of one or more of the above, and configure the processing device to operate as desired, or process it independently or collectively. You can command the device. Software and / or data may be any type of machine, component, physical device, virtual equipment, computer storage medium or device in order to be interpreted by or to provide instructions or data to the processing device. Or may be permanently or temporarily embodied in a signal wave to be transmitted. The software may be distributed over networked computer systems so that they may be stored or executed in a distributed manner. Software and data may be stored on one or more computer readable recording media.

The method according to the embodiment may be embodied in the form of program instructions that can be executed by various computer means and recorded in a computer readable medium. The computer readable medium may include program instructions, data files, data structures, etc. alone or in combination. The program instructions recorded on the media may be those specially designed and constructed for the purposes of the embodiments, or they may be of the kind well-known and available to those having skill in the computer software arts. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tape, optical media such as CD-ROMs, DVDs, and magnetic disks, such as floppy disks. Magneto-optical media, and hardware devices specifically configured to store and execute program instructions, such as ROM, RAM, flash memory, and the like. Examples of program instructions include not only machine code generated by a compiler, but also high-level language code that can be executed by a computer using an interpreter or the like. The hardware device described above may be configured to operate as one or more software modules to perform the operations of the embodiments, and vice versa.

Although the embodiments have been described by the limited embodiments and the drawings as described above, various modifications and variations are possible to those skilled in the art from the above description. For example, the described techniques may be performed in a different order than the described method, and / or components of the described systems, structures, devices, circuits, etc. may be combined or combined in a different form than the described method, or other components. Or even if replaced or substituted by equivalents, an appropriate result can be achieved.

Claims

An interval determination unit determining whether a first kernel program, which is operated according to the execution of the GPGPU application, from among one or more kernel programs; And

A frequency setting unit configured to set a first dynamic frequency when the graphic application is executed during the first time interval and set a second dynamic frequency when the GPGPU application is executed;

Mobile device comprising a.
The method of claim 1,

And the kernel program is an OpenCL kernel and the first kernel program includes a clEnqueue as a prefix.
The method of claim 1,

The frequency setting unit,

And setting the second dynamic frequency to a preset maximum frequency value.
The method of claim 3,

And wherein the maximum dynamic frequency value is preset to a plurality of step values, and updates a second dynamic frequency value to the closest of the plurality of steps based on past usage of the executed GPGPU application.
The method of claim 3,

And setting a threshold value reflecting a weight value corresponding to a time when a GPGPU application is executed during the first time interval, and updating a second dynamic frequency value based on the threshold value.
The method of claim 1,

The frequency setting unit,

And setting the dynamic frequency value determined as the first dynamic frequency value according to the predicted usage amount based on the past usage amount of the graphic application.
The method of claim 6,

And setting a threshold value reflecting a weight value corresponding to a time at which a graphic application is executed during the first time interval, and updating a first dynamic frequency value based on the threshold value.
The method of claim 1,

And updating the interval of the first time interval based on the execution time of the past application.
The method of claim 7, wherein

And updating the interval of the first time interval based on a standard deviation value with respect to the execution time of the past application.
A program stored in a computer readable recording medium for causing a computing device to operate a GPU in accordance with a dynamic frequency value,

An instruction set for determining whether to call a first kernel program operated according to execution of a GPGPU application among one or more kernel programs; And

Instruction set to set the first dynamic frequency when the graphics application is executed during the first time interval and the second dynamic frequency when the GPGPU application is executed

Program stored in the recording medium comprising a.
The method of claim 10,

Wherein the kernel program is an OpenCL kernel and the first kernel program includes a clEnqueue as a prefix.
The method of claim 10,

The instruction set for setting the first dynamic frequency or the second dynamic frequency may include:

And a dynamic frequency value determined according to the predicted usage amount based on past usage of the graphic application as a first dynamic frequency value or setting the second dynamic frequency to a preset maximum frequency value.
The method of claim 12,

The maximum dynamic frequency value is preset in a plurality of step values, and stored in the recording medium to update the second dynamic frequency value to the nearest value of the plurality of steps based on the past usage of the executed GPGPU application.
The method of claim 10,

During the first time interval, two threshold values reflecting weights according to the time when the graphic application is executed and the time when the GPGPU application is executed are set, and the first dynamic frequency or the second dynamic frequency value is set based on the respective threshold values. The program stored in the recording medium to be updated.
The method of claim 10,

The program stored in the recording medium for updating the interval of the first time interval based on the standard deviation value of the execution time of the past application.