Information processing program, information processing device, and information processing method

Abstract

Improve the efficiency of the second computing resource. [Solution] While a process is running using the second computing resource 10b, the expected value of the first time cost when releasing the second computing resource 10b, the expected value of the second time cost when continuing to hold the second computing resource 10b, and the current third time cost are calculated, and the second computing resource 10b is released if at least one of the following conditions is met: the expected value of the first time cost is less than the expected value of the second time cost, or the current third time cost exceeds a predetermined time cost limit.

Description

[Technical Field]

[0001] The present invention relates to an information processing program, an information processing device, and an information processing method. [Background technology]

[0002] It is known that using a GPU (Graphics Processing Unit) instead of a CPU (Central Processing Unit) to run deep learning applications (hereinafter referred to as deep learning applications) improves processing performance (for example, Patent Document 1).

[0003] Furthermore, the rapid development of AI in recent years has led to soaring GPU prices and supply shortages. Therefore, it is crucial to effectively share a limited number of GPUs among multiple processes.

[0004] In known job schedulers such as Slurm, GPUs are kept exclusively occupied from the start to the end of process execution, so it is not possible to run more jobs simultaneously than the number of GPUs available. Jobs that cannot secure a GPU are placed in the job queue and wait until the processes currently using the GPU have completely terminated.

[0005] Another known method for efficiently utilizing GPUs is GPU preemption. GPU preemption allows a job currently using a GPU to be stopped externally, transferring the right to use the GPU to another job. By performing such GPU preemption periodically, GPU usage processes can be switched on an hourly basis, allowing subsequent jobs to use the GPU without waiting for the preceding job to completely stop. [Prior art documents] [Patent Documents]

[0006] [Patent Document 1] Special Publication No. 2022-515302 [Patent Document 2] U.S. Patent Application Publication No. 2020 / 0073728 [Patent Document 3] Special table 2017-510004 publication [Patent Document 4] U.S. Patent Application Publication No. 2010 / 0100655 [Overview of the project] [Problems that the invention aims to solve]

[0007] In GPU preemption, the GPU remains occupied even if there are periods during process execution when it is not being used. To suppress such GPU occupation, it is necessary to switch GPU allocations according to the time changes in the processing content of the deep learning application, a process known as fine-grained allocation.

[0008] To achieve fine-grained GPU allocation, it is desirable to release the GPU when a process does not use it for an extended period of time.

[0009] Here, when a process releases the GPU, a process to release the GPU (GPU release process) is executed after the processing using the GPU (user processing), thereby releasing the GPU. Conversely, when a process reserves the GPU, a process to reserve the GPU (GPU reservation process) is executed, after which processing using the GPU (user processing) becomes available.

[0010] During the execution of these GPU release and GPU allocation processes, the GPU is reserved by the process, and these GPU release and allocation processes represent overhead related to GPU allocation.

[0011] Furthermore, the determination of whether or not a process is using the GPU is triggered by signals sent from the driver process to the process as interrupts at regular intervals.

[0012] Here, even if a process does not use the GPU for only a short time, if the process is not using the GPU at the time this signal is sent, the GPU release process described above will be executed. However, after a short period of time, the same process may use the same GPU again, in which case the GPU allocation process will be executed.

[0013] In other words, releasing the GPU at an inopportune time can result in unnecessary GPU release and allocation processes, potentially increasing the time required for a process to allocate the GPU and the execution time of processes using the GPU.

[0014] In one aspect, the present invention aims to improve the utilization efficiency of a second computing resource. [Means for solving the problem]

[0015] Therefore, in a computer having a first computing resource and a second computing resource having higher processing performance than the first computing resource, while a process is being executed using the second computing resource, the information processing program calculates the expected value of a first time cost when the second computing resource is released, the expected value of a second time cost when the second computing resource is retained, and the current third time cost. If at least one of the following conditions is met, the first condition is that the expected value of the first time cost is less than the expected value of the second time cost, or the second condition is that the current third time cost exceeds a predetermined time cost limit, the program causes the computer to execute a process to release the second computing resource. [Effects of the Invention]

[0016] According to one embodiment, the utilization efficiency of the second computing resource can be improved. [Brief explanation of the drawing]

[0017] [Figure 1]This diagram schematically shows the configuration of a scheduling system according to one embodiment. [Figure 2] This is a block diagram showing an example of a computer hardware (HW) configuration that realizes the functions of a scheduling system according to one embodiment. [Figure 3] This diagram illustrates the cost in a scheduling system according to one embodiment. [Figure 4] This figure shows an example of a graph of the probability density function f(d). [Figure 5] This figure shows an example of program code and SCC. [Figure 6] This figure illustrates a method for determining device continuity in a scheduling system according to one embodiment. [Figure 7] This is a flowchart illustrating the processing in a scheduling system according to one embodiment. [Figure 8] This is a flowchart illustrating the processing in a scheduling system according to one embodiment. [Figure 9] This diagram illustrates the expected cost of holding a device. [Modes for carrying out the invention]

[0018] Embodiments relating to this information processing program, information processing apparatus, and information processing method will be described below with reference to the drawings. However, the embodiments shown below are merely illustrative, and there is no intention to exclude various modifications or applications of technologies not explicitly shown in the embodiments. In other words, these embodiments can be implemented with various modifications without departing from their spirit. Furthermore, each figure is not intended to represent only the components shown in the figure, but may include other functions, etc.

[0019] (A) Configuration Figure 1 is a schematic diagram showing the configuration of a scheduling system 1 according to one embodiment, and Figure 2 is a block diagram showing an example of the hardware (HW) configuration of a computer 10 that implements the functions of the scheduling system 1 according to one embodiment.

[0020] (A-1) Example hardware configuration If multiple computers are used as hardware resources to implement the functions of scheduling system 1, each computer may have the hardware configuration illustrated in Figure 2.

[0021] Computer 10 is an information processing device, and as shown in Figure 2, its hardware configuration may include, as an example, one or more (two in the example shown in Figure 2) CPUs 10a-1, 10a-2, one or more (two in the example shown in Figure 2) GPUs 10b-1, 10b-2, memory 10c, storage unit 10d, IF (Interface) unit 10e, IO (Input / Output) unit 10f, and read unit 10g. Hereafter, CPUs 10a-1, 10a-2 will be referred to as CPU 10a unless specifically distinguished. Similarly, GPUs 10b-1, 10b-2 will be referred to as GPU 10b unless specifically distinguished.

[0022] The CPU 10a is an example of an arithmetic processing unit that performs various control and calculations, and is a control unit that executes various processes. The CPU 10a may be connected to each block in the computer 10 via a bus 10j so as to be able to communicate with each other. The bus 10j may be, for example, a PCIe (Peripheral Component Interconnect-Express) bus. The CPU 10a may be a multiprocessor containing multiple processors, a multicore processor having multiple processor cores, or a configuration having multiple multicore processors.

[0023] The GPU 10b may be an accelerator such as a GPGPU (General Purpose computing on Graphics Processing Unit). Furthermore, the GPU 10b may be used to control screen display for output devices such as monitors in the I / O unit 10f. The GPU 10b may be configured as an accelerator that performs machine learning processing and inference processing using machine learning models. Regarding machine learning processing and inference processing, the GPU 10b can be said to have higher processing performance than the CPU 10a.

[0024] These CPUs 10a-1, 10a-2, and GPUs 10b-1, 10b-2 are computing resources allocated to user programs executed by the user program execution unit 12, which will be described later. CPUs 10a-1 and 10a-2 are examples of first computing resources, while GPUs 10b-1 and 10b-2 are examples of second computing resources with higher processing performance compared to CPUs 10a-1 and 10a-2 (first computing resources). Hereafter, GPU 10b may be referred to as a device.

[0025] GPU10b-1 may be referred to as GPU#1, and GPU10b-2 as GPU#2. Similarly, CPU10a-1 may be referred to as CPU#1, and CPU10a-2 as CPU#2.

[0026] Memory 10c is an example of hardware that stores various data and program information. Examples of memory 10c include volatile memory such as DRAM (Dynamic Random Access Memory) and non-volatile memory such as PM (Persistent Memory), or both.

[0027] The storage unit 10d is an example of hardware that stores various data and program information. Examples of storage units 10d include magnetic disk devices such as HDDs (Hard Disk Drives), semiconductor drive devices such as SSDs (Solid State Drives), and various storage devices such as non-volatile memory. Examples of non-volatile memory include flash memory, SCM (Storage Class Memory), and ROM (Read Only Memory).

[0028] The memory unit 10d may store a program 10h (information processing program) that implements all or part of the various functions of the computer 10. For example, the CPU 10a of the scheduling system 1 can implement the various functions described later by loading the program 10h stored in the memory unit 10d into memory 10c and executing it.

[0029] Furthermore, the storage unit 10d may store various data used by the management process 3. The storage unit 10d may also function as a history information storage unit 16, which will be described later.

[0030] The IF unit 10e is an example of a communication interface that controls the connection and communication between this computer 10 and other computers. For example, the IF unit 10e may include an adapter compliant with LAN (Local Area Network) such as Ethernet®, or optical communication such as FC (Fibre Channel). The adapter may support wireless, wired, or both communication methods. The program 10h may be downloaded from the network to the computer 10 via the communication interface and stored in the storage unit 10d.

[0031] The I / O unit 10f may include either an input device or an output device, or both. Examples of input devices include keyboards, mice, and touch panels. Examples of output devices include monitors, projectors, and printers. The I / O unit 10f may also include a touch panel or the like that integrates the input and output devices. The output device may be connected to the GPU 10b. The I / O unit 10f may also be an input or output device of another information processing device remotely connected to this computer 10 via SSH (Secure Shell) or the like.

[0032] The reading unit 10g is an example of a reader that reads data and program information recorded on the recording medium 10i. The reading unit 10g may include a connection terminal or device to which the recording medium 10i can be connected or inserted. Examples of the reading unit 10g include an adapter compliant with USB (Universal Serial Bus), a drive device for accessing a recording disk, and a card reader for accessing flash memory such as an SD card. The recording medium 10i may store a program 10h, and the reading unit 10g may read the program 10h from the recording medium 10i and store it in the storage unit 10d.

[0033] Examples of recording media 10i include non-temporary computer-readable recording media such as magnetic / optical discs and flash memory. Examples of magnetic / optical discs include flexible discs, CDs (Compact Discs), DVDs (Digital Versatile Discs), Blu-ray discs, and HVDs (Holographic Versatile Discs). Examples of flash memory include semiconductor memory such as USB memory and SD cards.

[0034] The hardware configuration of computer 10 described above is illustrative. Therefore, the addition or deletion of hardware within computer 10 (for example, adding or deleting arbitrary blocks), division, integration in any combination, or addition or deletion of buses may be performed as appropriate.

[0035] (A-2) Example of Functional Configuration As shown in Figure 1, the scheduling system 1 may, for example, include the functions of a driver process 2, a management process 3, and a server process 4. These functions may be implemented by the hardware of computer 10 (see Figure 2). In the example shown in Figure 1, N GPUs 10b-1 to 10b-N are illustrated (where N is a natural number greater than or equal to 1).

[0036] The driver process 2 functions as a signal transmission unit 11. The signal processing unit 14 transmits at regular intervals (d int A signal is generated and sent to the user program execution unit 12. These signals are input to the user program execution unit 12 and the signal processing unit 14 as interrupts.

[0037] Management process 3 executes user programs and schedules the allocation of GPU10b (device) to one or more processes that arise as a result of executing these user programs. As shown in Figure 1, the management process 3 has the functions of a user program execution unit 12, a device hook unit 13, a signal processing unit 14, a cost calculation unit 15, and a history information storage unit 16.

[0038] The user program execution unit 12 executes the user program. The user program may be, for example, a program that implements the process of training (deep learning) a deep learning model (machine learning model).

[0039] The user program execution unit 12 executes a user program, generating one or more processes. The user program (process) is processed using either the GPU 10b or the CPU 10a. Hereinafter, when a user program or process is processed using the GPU 10b, it may be said that the user program uses the device or the process uses the device.

[0040] In processes generated by user programs (hereinafter simply referred to as "processes"), for example, in the training process of a deep learning model, calls are made to the APIs of deep learning libraries, thereby calling the libraries provided by each API. Deep learning libraries are software that functions as the base for user programs. Deep learning libraries are software that serves as the foundation for efficiently advancing machine learning by user programs, and may include, for example, processing patterns that are commonly used in user programs.

[0041] In this scheduling system 1, API calls made by user programs are input to the device hook unit 13 via hooks. If no computing resources are allocated to the user program, the device allocation server 17 sends information about the computing resource (GPU 10b) that will execute the API call.

[0042] Furthermore, when a user program moves the process it is currently executing to another computing resource, the device hook unit 13 may input a command to stop the user program or a command to restart the job on the new computing resource.

[0043] In this scheduling system 1, multiple user programs may be executed, and computing resources (CPU 10a, GPU 10b) may be allocated to each of these multiple user programs, and scheduling may be performed to execute these processes.

[0044] The user program is executed using the allocated computing resources (CPU10a, GPU10b).

[0045] When a user program finishes using a computing resource (GPU10b, device), it may notify the scheduler that it is releasing the computing resource (release notification). For example, when a user program finishes processing using GPU10b, it sends a GPU release notification to the scheduler. Similarly, when a user program finishes processing using CPU10a, it may send a CPU release notification to the scheduler.

[0046] The user program execution unit 12 receives signals transmitted from the signal transmission unit 11, and when this signal is received, the user program execution unit 12 may temporarily suspend the execution of the user program. The user program execution unit 12 may be implemented, for example, by a Python® interpreter, and the user program execution unit 12 may execute the program of the device hook unit 13, which will be described later.

[0047] The device hook unit 13 recognizes when a user program uses the device (GPU 10b). For example, the device hook unit 13 may receive an API call made by the user program through a hook, and based on this API call, it may determine whether or not the user program is using the GPU 10b. This allows the device hook unit 13 to recognize whether a process is requesting the use of the GPU 10b. It can be said that the device hook unit 13 detects the usage status of the GPU 10b. When the device hook unit 13 detects device use by a user program, it also checks whether the device is allocated.

[0048] Furthermore, when the device hook unit 13 releases the GPU 10b, if there is data (device data) being processed by the GPU 10b, it stores (moves, saves) that device data in the history information storage unit 16 as device save data 22.

[0049] Furthermore, before using the allocated GPU 10b, if there is any saved device data for the GPU 10b, the device hook unit 13 reads the device data from the device saved data 22 and restores it to the GPU 10b.

[0050] The history information storage unit 16 stores various history information obtained as a result of the user program execution unit 12 executing the user program.

[0051] In the example shown in Figure 1, the history information storage unit 16 stores device last usage time information 21, device backup data 22, discontinuous section history 23, discontinuous section start information 24, device data count information 25, and device data size information 26.

[0052] The device last used time information 21 is the time when the process stopped using the device, and the completion time of the last process the device handled t last This includes the following. Device backup data 22 is the data (device data) that was being processed on the device being released. Discrete interval history 23 is the length of the discontinuous (unused) period of the device d. nouse Includes.

[0053] The discontinuous section start information 24 includes the program execution position (stmt) when the discontinuous section was detected and the time (t) when this stmt was recorded. saved ) and the following are included. Device data count information 25 includes the number of data being processed by the device, and device data size information 26 includes the size of the data being processed by the device.

[0054] This data is generated each time a device (GPU10b) performs processing, and is also generated for each device.

[0055] The cost calculation unit 15 calculates the time cost according to instructions from the signal processing unit 14, which will be described later. In this scheduling system 1, the time during which the GPU 10b (device) cannot be effectively used is defined as the time cost. Hereafter, the time cost will simply be referred to as the cost.

[0056] FIG. 3 is a diagram for explaining the cost in the scheduling system 1 according to an embodiment. In this FIG. 3, reference sign A indicates the cost when holding a device, and reference sign B indicates the cost when releasing the device.

[0057] Here, time t now represents the current time, and t last represents the execution completion time of the process that the device last processed. Also, t next represents the time when the process starts using the device next. d last represents the period from time t last to time t now and d next represents the period from time t now to time t next As shown by reference sign A in FIG. 3, the cost Cost hold (t next ) when holding a device can be expressed by the following formula (1).

[0058] Cost hold (t next ) = t next ​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​(t=tt) last (2) Furthermore, the cost calculation unit 15 calculates the expected cost E(Cost) when the device is held. hold ) is calculated using the following formula (3). Here, t next Since this is unknown, the cost calculation unit 15 may calculate the expected value of the cost using the probability density function f(d). f(d) is the time (t) when the device was last used. last This is the probability of it being used d seconds after ).

[0061]

number

[0062]

number

[0063] Expected cost E(Cost) when holding the device hold This is an example of the expected second time cost when retaining GPU10b (the second computing resource, device).

[0064] Expected cost E(Cost) when holding the device hold ) is the completion time t of the last process processed by GPU10b (second computing resource, device). last Starting from this point, the start time for the next use of GPU10b (the second computing resource, device) is calculated using a probability density function that expresses this as a probability density.

[0065] Figure 4 shows an example of a graph of the probability density function f(d).

[0066] In the graph shown in Figure 4, the vertical axis represents probability, and the horizontal axis represents the completion time t of the last process processed by the device. last This represents the interval from time t to time d. Note that d=0 represents the time when the device was last used. Threshold d threshPreviously, this referred to the case where the device was used continuously, with a threshold of d thresh From here on, we will show cases where the device is used discontinuously (discontinuous interval). The discontinuous interval is defined as d ≥ d thresh By doing so, we can effectively ignore the case where the value of f(d) is large, thereby reducing computational costs.

[0067] Furthermore, various known probability density functions may be used as the probability density function; for example, the gamma distribution may be used.

[0068] The gamma distribution is applied, for example, to the distribution of time to product failure. The probability density function of the gamma distribution is defined as follows:

[0069]

number

[0070] Here, the average occurrence interval θ may be estimated based on the current user program execution position and the history of past discontinuous intervals.

[0071] The interval until the next device is used is d nouse In this scheduling system 1, simply past d nouse Instead of averaging, a weighted average based on the program's distance is used. The average occurrence interval θ can be calculated using the following equation (4).

[0072]

number

[0073] For distance calculation, you can use, for example, the Strongly Connected Component (SCC). The SCC is the set of nodes that can move between each other when each tament is represented as a directed graph.

[0074] Two statements stmt i and stmt j The distance between them can be defined as the number of SCCs (Surface Cross-Conditional Cross-Conditions) crossed from one point to the other.

[0075] Figure 5 shows an example of program code and SCC.

[0076] In Figure 5, code A represents an example of program code, and code B represents an example of SCC corresponding to the program code shown in code A.

[0077] In the program code illustrated in Figure 5, there are stmt0 to stmt3 as indicated by symbol A. The distance between stmt1 and stmt2 is 0. The distance between stmt0 and stmt3 is 2. In such a case, for example, the weight w is as shown in equation (5) below. i You may set it.

[0078] w i =1 / (1+distance(stmt cur ,stmt i ))···(5) Note that the above equation (5) is based on the weight w i This is just one example of how to determine this, and it is not necessarily limited to equation (5), but can be modified as appropriate. Furthermore, as shown by symbol B in Figure 3, the cost when releasing the device is Cost release (t now ) can be expressed by the following equation (6).

[0079] Cost release (t now )=d last +d rel_cur +d alloc_next...(6) In this equation (6), d rel_cur d represents the time required from the start to the completion of the device release process. alloc_next This represents the time required from the start to the completion of the device allocation process.

[0080] Expressing equation (6) above as a general formula using an arbitrary time t, it can be expressed as equation (7), which is the cost function when the device is released.

[0081] Cost release (t) = (tt last )+d rel_cur +d alloc_next ...(7) d rel_cur and d alloc_next This can be calculated using the following equations (8) and (9). Note that the current number of device data points is counted. cur Then, count the following device data counts next Let's assume that the current device data size is size cur The next device data size is size next Let L be the minimum latency during data transfer to the device, and T be the maximum throughput.

[0082] d rel_cur =L × count cur +size cur / T ···(8) d alloc_next =L × count next +size next / T ···(9) Furthermore, the cost calculation unit 15 calculates the expected cost E(Cost) when the device is released. release ) is calculated using the following equation (10). Since this is the expected value when freed at this point, t=t now Use the value.

[0083] E(Cost release ) =( t now-t last )+d rel_cur +d alloc_next (10) The expected cost E(Cost) when releasing the device release This is an example of the expected time cost of the first option when GPU10b (the second computing resource, device) is released.

[0084] The expected cost E(Cost) when releasing the device release ) is the completion time t of the last process processed by GPU10b (second computing resource, device). last From the current time t now The elapsed time up to that point, and the time d required to release GPU10b (the second computing resource, device). rel_cur And the time d required to secure GPU10b (second computing resource, device) alloc_next It is calculated by adding the two together.

[0085] Furthermore, if a user program uses the GPU 10b and the GPU 10b has not been allocated to that user program, the device hook unit 13 requests the device allocation server 17 to allocate the GPU 10b to the user program.

[0086] Furthermore, the device hook unit 13 detects the completion time of the process t last You may update the device data size information 26, discontinuous interval history 23, discontinuous interval start information 24, and device data count information 25.

[0087] The signal processing unit 14 receives signals transmitted from the signal transmission unit 11, and processing begins upon receiving these signals.

[0088] For example, the signal processing unit 14 causes the cost calculation unit 15 to perform cost calculations each time a signal is input.

[0089] Also, when a predetermined device release condition is satisfied, the signal processing unit 14 determines the release of the GPU 10b. The device release condition may be, for example, that the following two release conditions are satisfied.

[0090] [Release Condition 1] The utilization of the GPU 10b by the process P cur is discontinuous.

[0091] [Release Condition 2] At least one of the following inequalities (a) and (b) is satisfied.

[0092] Inequality (a): E hold ≧ E release Inequality (b): Cost hold (t now ) > Cost limit In Inequality (a), E hold is the expected value of the cost when continuing to hold the device, and E release is the expected value of the cost when releasing the device.

[0093] Also, in Inequality (b), Cost hold (t now ) is the current cost, and it is a value obtained by applying the current time (t now ) to the equation of the cost function when holding the device shown in the above formula (2). Also, Cost limit is the cost limit value.

[0094] The current cost Cost hold (t now ) is an example of the current third time cost. This current cost Cost hold (t now ) is calculated based on the execution completion time t last of the process last processed by the GPU 10b (the second computing resource, device).

[0095] Relying solely on the cost expectation shown in inequality (a) may result in the current process holding the device for an extended period. In such cases, other processes that wish to use the device would have to wait until the current process terminates.

[0096] Therefore, in this scheduling system 1, the current cost function value is the cost limit value Cost limit The device will be released if the cost limit is exceeded. limit For example, the cost calculation unit 15 may query the device allocation server 17 for the device request status of other processes and make a decision according to that device request status. Alternatively, the user may set a cost limit value in advance. limit You can set any value as this and modify it as appropriate before implementing it.

[0097] Process P of release condition 1 described above cur The discontinuous use of GPU10b by a process is an example of the third condition, which is discontinuous use of GPU10b (the second computing resource / device) by a process.

[0098] Furthermore, releasing GPU10b (the second computing resource, device) when both release condition 1 and release condition 2 are met is an example of releasing GPU10b (the second computing resource, device) when the third condition, that the process's use of GPU10b (the second computing resource, device) is discontinuous, is met, and at least one of the first or second condition is met.

[0099] Here, process P of release condition 1. cur In determining the continuity of GPU10b usage, the period of time during which GPU10b is not used by a process is threshold d. thresh If the value is less than a certain number, it can be considered continuous.

[0100] Figure 6 is a diagram illustrating a device continuity determination method in a scheduling system 1 according to one embodiment.

[0101] Figure 6 shows an example of a process using a device intermittently. Each shaded rectangle in the figure represents a period in which the process is using the device, while the white areas (gaps) between two adjacent shaded rectangles represent periods in which the process is not using the device (non-use periods).

[0102] The signal processing unit 14 determines that the gap between two adjacent shaded rectangles, i.e., the period of device non-use due to the process, is threshold d. thresh If it is less than , it is considered continuous. The signal processing unit 14 then determines that the gap between two adjacent shaded rectangles, i.e., the period of device non-use by the process, is threshold d thresh If the above conditions are met, the period of non-use of GPU10b by the process in question will be considered discontinuous.

[0103] Furthermore, regarding release condition 2, the probability density function f(t) of the time until GPU10b is used next may be used to calculate the expected value. f(t) is generated based on the history of discontinuous intervals in past user program executions. Furthermore, the signal processing unit 14 controls the allocation of the GPU 10b to user programs (processes). The signal processing unit 14 requests the device allocation server 17 to allocate or release the GPU 10b for user programs.

[0104] When the signal processing unit 14 decides to release the GPU 10b, it notifies the device allocation server 17 of a request to release the GPU 10b that is allocated to the user program (release request).

[0105] The device assignment server 17, in response to a device assignment request from the device hook unit 13, assigns a device to a process (user program) and has it perform processing. The device assignment server 17 may also manage the assignment status of the device (GPU 10b).

[0106] The function of device assignment server 17 is already known, so its explanation will be omitted.

[0107] (B) Operation The processing in the scheduling system 1 according to one embodiment configured as described above will be explained according to the flowcharts (steps S1 to S26) shown in Figures 7 and 8.

[0108] Figure 7 shows the process from steps S1 to S16, and Figure 8 shows the process from steps S17 to S26.

[0109] In step S1, the signal transmission unit 11 generates a signal and transmits it to the user program execution unit 12.

[0110] In step S2, the signal transmission unit 11 transmits for a specified time (d int ) Wait, then proceed to step S3.

[0111] In step S3, the driver process 2 checks whether the user program execution unit 12 has finished executing the user program. If the user program has not finished (see No. route in step S3), it returns to step S1.

[0112] Furthermore, if the execution of the user program by the user program execution unit 12 is completed (see the Yes route in step S3), the process will terminate.

[0113] Furthermore, in step S4, the user program execution unit 12 executes the user program in one step.

[0114] In step S5, the management process 3 checks whether the device hook unit 13 has detected device usage by a user program. If the device hook unit 13 has detected device usage by a user program (see the Yes route in step S5), in step S6, it checks whether the device is reserved. If the device is reserved (see the Yes route in step S6), the process proceeds to step S7.

[0115] In step S7, the user program execution unit 12 executes the user program's processing on the assigned device (assigned device). Also, in step S8, the device hook unit 13 uses the current time to determine the execution completion time t of the last process processed by the device in the device last usage time information 21. last Update.

[0116] Furthermore, in step S9, the device hook unit 13 updates the device data size information 26 and the device data count information 25.

[0117] In step S10, the user program execution unit 12 checks whether it has received a signal from the signal processing unit 14. If it has not received a signal (see No. route in step S10), it proceeds to step S11.

[0118] Furthermore, if the device hook unit 13 does not detect device usage by a user program in step S5 (see No route in step S5), steps S6 to S9 are skipped and the process proceeds to step S10.

[0119] In step S11, the user program execution unit 12 checks whether the user program has terminated. If the user program has terminated (see the Yes route in step S11), the process terminates.

[0120] Furthermore, if the user program does not terminate (see No. route in step S11), return to step S4.

[0121] Furthermore, if the device is not secured as a result of the check in step S6 (see No route in step S6), proceed to step S12.

[0122] In step S12, the device hook unit 13 checks if discontinuous section start information 24 exists in the history information storage unit 16. If the check confirms that discontinuous section start information 24 exists (see Yes route in step S12), the device hook unit 13 proceeds to step S13. In step S13, the device hook unit 13 checks if the discontinuous section history 23 contains d nouse For (current time - t saved The discontinuous section history 23 is updated by adding ). The device hook unit 13 also deletes the discontinuous section start information 24.

[0123] In step S14, the device hook unit 13 secures a device on which to run the user program by requesting a device assignment from the device assignment server 17.

[0124] Furthermore, if there is no discontinuous section start information 24 in step S12 (see No. route in step S12), step S13 is skipped and the process proceeds to step S14.

[0125] In step S15, the device hook unit 13 checks whether device backup data 22 exists for the secured device. If the device backup data 22 does not exist (see No route in step S15), the process returns to step S7.

[0126] Furthermore, if device backup data 22 exists (see the Yes route in step S15), in step S16, the device hook unit 13 reads the device backup data 22 and restores it to the secured device. After that, the process returns to step S7.

[0127] Furthermore, if a signal is received from the signal processing unit 14 as a result of the verification in step S10 (see the Yes route in step S10), the process proceeds to step S17 in Figure 8 (see symbol (A)).

[0128] In step S17, the device hook unit 13 checks whether another process has requested the device. If no other process has requested the device (see No route in step S17), the process returns to step S11 in Figure 7 (see reference numeral (B)).

[0129] Furthermore, if another process requests the device (see the Yes route in step S17), the process proceeds to step S18. In step S18, the signal processing unit 14 receives the current time t now Using d nouse =t now -t last By calculating d nouse We seek.

[0130] In step S19, the signal processing unit 14, nouse ga d thresh Check if the above is true. d nouse ga d thresh If the above conditions are met (see the Yes route in step S19), proceed to step S20.

[0131] In step S20, the cost calculation unit 15 uses the device data size and the number of device data to calculate the cost of releasing the device. release And its expected value E(Cost release ) and calculate.

[0132] Furthermore, the cost calculation unit 15 uses the current code execution position and the discontinuous interval history 23 to calculate the cost of holding the device. hold (t next ) and its expected value E(Cost hold ) and calculate.

[0133] Furthermore, the cost calculation unit 15 calculates the cost limit value Cost limit This is determined, for example, based on the device request status of other processes.

[0134] In step S21, the signal processing unit 14 checks whether the device release condition is met. That is, the signal processing unit 14 checks whether the device release condition is met. hold ≧E release or Cost hold (t now )>Cost limit Check if at least one of the following conditions is true.

[0135] If the device release condition is met (see Yes route in step S21), then in step S22, the signal processing unit 14 checks whether data (device data) exists on the device to be released. If device data exists on the device to be released (see Yes route in step S22), in step S23, the device hook unit 13 saves the device data to the history information storage unit 16 as device save data 22.

[0136] In step S24, the device hook unit 13 notifies the device allocation server 17 that the device has been released.

[0137] Furthermore, if no device data exists for the device to be released in step S22 (see No route in step S22), step S23 is skipped and the process proceeds to step S24.

[0138] In step S25, the user program execution unit 12 checks in the history information storage unit 16 whether discontinuous section start information 24 exists. If discontinuous section start information 24 does not exist (see No route in step S25), the program proceeds to step S26.

[0139] In step S26, the user program execution unit 12 determines the current user program position stmt,d nouse and the current time tsaved This is saved as discontinuous section start information 24. Then, the process returns to step S11 in Figure 7 (see symbol (B)).

[0140] Furthermore, as a result of the verification in step S19, d nouse ga d thresh If it is less than (see the No route in step S19), return to step S11 in Figure 7 (see symbol (B)). Furthermore, if the discontinuous section start information 24 exists as a result of the check in step S25 (see the Yes route in step S25), return to step S11 in Figure 7 (see symbol (B)).

[0141] Furthermore, as a result of the verification in step S21, E hold ≧E release or Cost hold (t now )>Cost limit If none of the above conditions are met, i.e., if the device release conditions are not met (see No route in step S21), proceed to step S25.

[0142] (C) Effects Thus, in the scheduling system 1 as an example of the embodiment, the time during which the device cannot be effectively used is treated as a cost (time cost). Furthermore, the cost calculation unit 15 calculates the expected cost E(Cost) of continuing to hold the device. hold ) and the expected cost E(Cost) when releasing the device release ) and calculate.

[0143] And the expected cost of releasing the device (Cost release ) is the expected cost E(Cost) of continuing to hold the device. hold The device is released when the threshold falls below a certain level. This allows other processes to use the device, improving its utilization efficiency.

[0144] Furthermore, the cost calculation unit 15 calculates the current cost (Cost hold (tnow The signal processing unit 14 calculates the current cost (Cost hold (t now )) and cost limit value Cost limit Compare this with the current cost. hold (t now )) is the cost limit value Cost limit The device is released when the limit is exceeded. This improves the efficiency of device utilization.

[0145] Furthermore, the signal processing unit 14 controls process P cur When the use of GPU10b is discontinuous, what is the expected cost of releasing the device? release ) is the expected cost E(Cost) of continuing to hold the device. hold The device is released if the value falls below a certain threshold. This allows us to exclude regions where the value of f(d) is large in the probability density function f(d) used to calculate the expected cost of holding the device, thereby reducing computational costs.

[0146] Furthermore, the cost calculation unit 15 performs cost calculations each time a signal is transmitted from the signal transmission unit 11. This allows for a fine-grained decision on whether or not to release the device, enabling device switching at the optimal timing.

[0147] (D) Other The disclosed technology is not limited to the embodiments described above and can be implemented in various modified forms without departing from the spirit of this embodiment.

[0148] For example, in the embodiment described above, weight w i The calculation uses a programmatic distance, but is not limited to this. For example, the time t in the history saved It may also be used, and can be implemented in various modified forms.

[0149] Furthermore, although the embodiments described above show an example where the device is a GPU 10b, the device is not limited to this. The device may be a processor other than a GPU 10b. Also, the device is not limited to a processor, but may be other components provided in the computer 10.

[0150] Furthermore, some of the processes among the management process 3, driver process 2, and server process 4 may be executed by other processors instead of CPU 10a. Also, some of the functions included in the management process 3 (for example, the function as the device hook unit 13) may be executed by other processors.

[0151] Other processors may include, for example, one of the following: MPU (Micro Processing Unit), DSP (Digital Signal Processor), ASIC (Application Specific Integrated Circuit), PLD (Programmable Logic Device), or FPGA (Field Programmable Gate Array). Furthermore, a processor may be a combination of two or more elements from among CPU, MPU, DSP, ASIC, PLD, and FPGA.

[0152] Furthermore, in addition to the expected value of the cost, probability and its threshold can also be used as criteria for deciding when to release a device.

[0153] Figure 9 illustrates a decision-making method based on the probability of the next access occurring during the time it takes for resources to become available again after being released.

[0154] In Figure 9, sign A shows an example of a graph of the probability density function f(d), and sign B shows the probability that it is better to hold the device than to release it.

[0155] In the graph of the probability density function f(d) shown by sign A in Figure 9, time t now The subsequent region b is at the current time tnow This represents the total probability of an access occurring from this point onward. now The region a from time t represents the probability that the next access will occur during the time it takes for the resource to become available again after resource release.

[0156] current time t now If the ratio of the probability of the next access occurring within the time it takes for resources to become available again after resource release to the total probability of subsequent access occurring is above a predetermined threshold, it is determined that there is an immediate access to the device, and the device can be used efficiently by occupying it.

[0157] On the other hand, the current time t now If the ratio of the probability of the next access occurring within the time it takes for the resource to become available again after resource release is below a predetermined threshold, it can be determined that there has been no immediate access to the device, and the device can be released, thereby enabling efficient use of the device.

[0158] Note, now +d rel_cur +d alloc_next This represents the shortest access time when releasing the device.

[0159] Furthermore, the above disclosure makes it possible for those skilled in the art to implement and manufacture this embodiment.

[0160] (E) Note The following additional information is disclosed regarding the embodiments described above.

[0161] (Note 1) In a computer having a first computing resource and a second computing resource having higher processing performance than the first computing resource, While the process is running using the second computing resource, The expected value of the first time cost when the second computing resource is released, the expected value of the second time cost when the second computing resource is retained, and the current third time cost are calculated. The second computing resource is released if at least one of the following conditions is met: the expected value of the first time cost is less than the expected value of the second time cost, or the current third time cost exceeds a predetermined time cost limit. An information processing program characterized by causing the computer to perform the processing.

[0162] (Note 2) If the third condition is met, which is that the use of the second computing resource by the process is discontinuous, and if at least one of the first or second condition is met, the second computing resource is released. The information processing program described in Appendix 1, characterized in that it causes the computer to perform the processing.

[0163] (Note 3) The process for calculating the expected value of the first time cost is as follows: The process includes calculating the expected value of the first time cost by summing the elapsed time from the completion time of the process last processed by the second computing resource to the present time, the time required to release the second computing resource, and the time required to secure the second computing resource. The information processing program described in Appendix 1, characterized by the features described herein.

[0164] (Note 4) The process for calculating the expected value of the second time cost is as follows: The process includes calculating the expected value of the second time cost using a probability density function that starts from the completion time of the process last processed by the second computing resource and represents the start time of the next use of the second computing resource as the probability density. The information processing program described in Appendix 1, characterized by the features described herein.

[0165] (Note 5) The process for calculating the current third time cost is as follows: This process includes calculating the current third time cost based on the completion time of the process last processed by the second computing resource. The information processing program described in Appendix 1, characterized by the features described herein.

[0166] (Note 6) An information processing device having a first computing resource and a second computing resource having higher processing performance than the first computing resource, While the process is running using the second computing resource, The expected value of the first time cost when the second computing resource is released, the expected value of the second time cost when the second computing resource is retained, and the current third time cost are calculated. The second computing resource is released if at least one of the following conditions is met: the expected value of the first time cost is less than the expected value of the second time cost, or the current third time cost exceeds a predetermined time cost limit. An information processing device characterized by comprising a control unit that performs processing.

[0167] (Note 7) The control unit, If the third condition is met, which is that the use of the second computing resource by the process is discontinuous, and if at least one of the first or second condition is met, the second computing resource is released. The information processing apparatus according to Appendix 6, characterized by performing processing.

[0168] (Note 8) The process for calculating the expected value of the first time cost is as follows: The process includes calculating the expected value of the first time cost by summing the elapsed time from the completion time of the process last processed by the second computing resource to the present time, the time required to release the second computing resource, and the time required to secure the second computing resource. The information processing apparatus described in Appendix 6, characterized in that it is a processing apparatus.

[0169] (Note 9) The process for calculating the expected value of the second time cost is as follows: The process includes calculating the expected value of the second time cost using a probability density function that starts from the completion time of the process last processed by the second computing resource and represents the start time of the next use of the second computing resource as the probability density. The information processing apparatus described in Appendix 6, characterized in that it is a processing apparatus.

[0170] (Note 10) The process for calculating the current third time cost is as follows: This process includes calculating the current third time cost based on the completion time of the process last processed by the second computing resource. The information processing apparatus described in Appendix 6, characterized in that it is a processing apparatus.

[0171] (Note 11) In a computer having a first computing resource and a second computing resource having higher processing performance than the first computing resource, While the process is running using the second computing resource, The expected value of the first time cost when the second computing resource is released, the expected value of the second time cost when the second computing resource is retained, and the current third time cost are calculated. The second computing resource is released if at least one of the following conditions is met: the expected value of the first time cost is less than the expected value of the second time cost, or the current third time cost exceeds a predetermined time cost limit. An information processing method characterized in that the processing is performed by the computer.

[0172] (Note 12) If the third condition is met, which is that the use of the second computing resource by the process is discontinuous, and if at least one of the first or second condition is met, the second computing resource is released. The information processing method according to Appendix 11, characterized in that the processing is performed by the computer.

[0173] (Note 13) The process for calculating the expected value of the first time cost is as follows: The process includes calculating the expected value of the first time cost by summing the elapsed time from the completion time of the process last processed by the second computing resource to the present time, the time required to release the second computing resource, and the time required to secure the second computing resource. The information processing method described in Appendix 11, characterized by the features described herein.

[0174] (Note 14) The process for calculating the expected value of the second time cost is as follows: The process includes calculating the expected value of the second time cost using a probability density function that starts from the completion time of the process last processed by the second computing resource and represents the start time of the next use of the second computing resource as the probability density. The information processing method described in Appendix 11, characterized by the features described herein.

[0175] (Note 15) The process for calculating the current third time cost is as follows: This process includes calculating the current third time cost based on the completion time of the process last processed by the second computing resource. The information processing method described in Appendix 11, characterized by the features described herein. [Explanation of Symbols]

[0176] 1. Scheduling System 10 Computers 10a-1, 10a-2, 10a CPU 10b-1, 10b-2, 10b GPU 10c memory 10d storage section 10e IF section 10f IO section 10g reading unit 10-hour program 10i recording media 10j bus 2. Driver Process 3. Management Process 4 Server Processes 11. Response transmission unit 12 User Program Execution Unit 13 Device hook section 14. Signal Processing Unit 15. Cost Calculation Department 16 History Information Storage Unit 17. Device Assignment Server 21 Device Last Usage Time Information 22 Device backup data 23. Discontinuous section history 24. Information on the start of discontinuous sections 25 Device data count information 26. Device Data Size Information

Claims

1. In a computer having a first computing resource and a second computing resource having higher processing performance than the first computing resource, During the execution of the process using the second computing resource, The expected value of the first time cost when the second computing resource is released, the expected value of the second time cost when the second computing resource is retained, and the current third time cost are calculated. The second computing resource is released if at least one of the following conditions is met: the expected value of the first time cost is less than the expected value of the second time cost, or the current third time cost exceeds a predetermined time cost limit. An information processing program characterized by causing the computer to perform the processing.

2. If the third condition is met, which is that the use of the second computing resource by the process is discontinuous, and if at least one of the first or second condition is met, the second computing resource is released. The information processing program according to claim 1, characterized in that it causes the computer to perform the processing.

3. The process for calculating the expected value of the first time cost is as follows: The information processing program according to claim 1, characterized in that it includes a process for calculating the expected value of the first time cost by summing the elapsed time from the completion time of the process last processed by the second computing resource to the present time, the time required to release the second computing resource, and the time required to secure the second computing resource.

4. The process for calculating the expected value of the second time cost is as follows: The process includes calculating the expected value of the second time cost using a probability density function that starts from the completion time of the process last processed by the second computing resource and represents the start time of the next use of the second computing resource as a probability density. The information processing program according to feature 1.

5. The process for calculating the current third time cost is as follows: This process includes calculating the current third time cost based on the completion time of the process last processed by the second computing resource. The information processing program according to feature 1.

6. An information processing device having a first computing resource and a second computing resource having higher processing performance than the first computing resource, During the execution of the process using the second computing resource, The expected value of the first time cost when the second computing resource is released, the expected value of the second time cost when the second computing resource is retained, and the current third time cost are calculated. The second computing resource is released if at least one of the following conditions is met: the expected value of the first time cost is less than the expected value of the second time cost, or the current third time cost exceeds a predetermined time cost limit. An information processing device characterized by comprising a control unit that performs processing.

7. In a computer having a first computing resource and a second computing resource having higher processing performance than the first computing resource, During the execution of the process using the second computing resource, The expected value of the first time cost when the second computing resource is released, the expected value of the second time cost when the second computing resource is retained, and the current third time cost are calculated. The second computing resource is released if at least one of the following conditions is met: the expected value of the first time cost is less than the expected value of the second time cost, or the current third time cost exceeds a predetermined time cost limit. An information processing method characterized in that the processing is performed by the computer.

Images