KR101960609B1 - A method and apparatus for managing gpu resources by task group unit - Google Patents

Abstract

A method and apparatus for managing GPU resources are disclosed. A GPU resource management method according to an exemplary embodiment of the present invention includes reserving resources of a GPU on a time basis, measuring usage time of the resources, and scheduling the resources based on the usage time do.

Description

METHOD AND APPARATUS FOR MANAGING GPU RESOURCES BY TASK GROUP UNIT

The following embodiments relate to a GPU resource management method and apparatus.

GPGPU (General-Purpose Computing on Graphics Process Units) is a technology that allows general-purpose calculations to be performed on Graphics Processing Unit (GPU) hardware. Unlike CPUs, GPU hardware has thousands of cores, which can be processed in parallel, resulting in high computational complexity. Therefore, in case of high computational work such as machine learning or pattern recognition, it is expected that significant performance improvement can be expected when GPU hardware is operated on GPU hardware.

Embodiments can provide a technique for managing GPU resources by adjusting the usage time of the GPU.

A GPU resource management method according to an exemplary embodiment of the present invention includes reserving resources of a GPU on a time basis, measuring usage time of the resources, and scheduling the resources based on the usage time do.

The reserving may include determining whether to reserve the resource using a resource utilization period based on the resource management period of the GPU and the available time of the resource per the resource management period.

Wherein the step of reserving includes storing overrun time used for a plurality of users in excess of the resource management period, the available time of the resource, the total usage time of the resource, and the reservation time for the GPU .

Wherein the measuring comprises: inserting an event for measuring the execution time of the kernel at the beginning and end of a kernel executed by the GPU; and measuring the execution time using the event can do.

Wherein the scheduling step includes a step of summing up the use time, a step of determining whether to execute the kernel in this period based on the reservation time for the GPU, the usable time of the GPU, and the usage time until the present cycle of the GPU And a step of determining the number

Wherein the determining comprises determining whether there is an overrun time in excess of a reservation time for the GPU, comparing the overrun time and the reservation time first, A second comparing step of comparing a use time of the overrun time and the usable time of the overrun time with a usable time of the overrun time; And updating the available time and the overrun time based on the third comparison result and determining whether to execute the kernel.

The scheduling may schedule the resource for each resource management period of the GPU.

The measuring step may measure the use time using a separate thread.

The GPU resource management apparatus according to an embodiment includes a controller that reserves a resource of a GPU on a time basis, measures a use time of the resource, and schedules the resource based on the usage time.

The controller may include a resource reservation unit that reserves resources of the GPU on a time basis, a usage time meter that measures the usage time of the resource, and a scheduler that schedules the resource based on the usage time .

The resource reservator may determine whether to reserve the resource by using a resource utilization rate based on a resource management period of the GPU and a usable time of the resource per the resource management period.

The resource reservator may store an overrun time used by the plurality of users in excess of the resource management period, the available time of the resource, the total usage time of the resource, and the reservation time for the GPU.

The use time meter may insert an event for measuring the execution time of the kernel at the start and end of the kernel executed by the GPU, and may use the event to measure the execution time.

The scheduler may sum up the usage time and determine whether to run the kernel at this time based on the reservation time for the GPU, the available time of the GPU, and the usage time up to the present cycle of the GPU.

Wherein the scheduler comprises: an overrun determinator for determining whether an overrun time exceeding a reserved time for the GPU exists; a first comparator for comparing the overrun time and the reserved time first, A second comparator for comparing the use time and the usable time before the overrun time and the usable time; a third comparator for comparing the overrun time and the usable time third by a third comparator; And a determiner for updating the available time and the overrun time based on the second comparison result and the third comparison result and determining whether to execute the kernel.

The scheduler may schedule the resource for each resource management period of the GPU.

The use time meter may measure the use time by using a separate thread.

1 shows a schematic block diagram of a GPU resource management apparatus according to an embodiment.
Fig. 2 shows an example of the structure of the GPU resource management apparatus shown in Fig.
Figure 3 shows a schematic block diagram of the controller shown in Figure 1;
Fig. 4 shows an example of the structure of the resource reservation unit shown in Fig.
Figure 5 shows a schematic block diagram of the scheduler shown in Figure 3;
6 shows an example of a flow chart of the operation of the scheduler shown in Fig.

It is to be understood that the specific structural or functional descriptions of embodiments of the present invention disclosed herein are presented for the purpose of describing embodiments only in accordance with the concepts of the present invention, May be embodied in various forms and are not limited to the embodiments described herein.

Embodiments in accordance with the concepts of the present invention are capable of various modifications and may take various forms, so that the embodiments are illustrated in the drawings and described in detail herein. However, it is not intended to limit the embodiments according to the concepts of the present invention to the specific disclosure forms, but includes changes, equivalents, or alternatives falling within the spirit and scope of the present invention.

The terms first, second, or the like may be used to describe various elements, but the elements should not be limited by the terms. The terms may be named for the purpose of distinguishing one element from another, for example without departing from the scope of the right according to the concept of the present invention, the first element being referred to as the second element, Similarly, the second component may also be referred to as the first component.

It is to be understood that when an element is referred to as being "connected" or "connected" to another element, it may be directly connected or connected to the other element, . On the other hand, when an element is referred to as being "directly connected" or "directly connected" to another element, it should be understood that there are no other elements in between. Expressions that describe the relationship between components, for example, "between" and "immediately" or "directly adjacent to" should be interpreted as well.

The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. The singular expressions include plural expressions unless the context clearly dictates otherwise. In this specification, the terms "comprises ", or" having ", and the like, are used to specify one or more of the features, numbers, steps, operations, elements, But do not preclude the presence or addition of steps, operations, elements, parts, or combinations thereof.

Unless defined otherwise, all terms used herein, including technical or scientific terms, have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs. Terms such as those defined in commonly used dictionaries are to be interpreted as having a meaning consistent with the meaning of the context in the relevant art and, unless explicitly defined herein, are to be interpreted as ideal or overly formal Do not.

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

1 shows a schematic block diagram of a GPU resource management apparatus according to an embodiment.

Referring to FIG. 1, a graphics processing unit (GPU) resource management apparatus 10 can manage resources of a GPU. The GPU resource management device 10 can perform scheduling so that a plurality of users such as a server can share resources of the GPU installed in the equipment and process the tasks so that the resources can be effectively used by a plurality of users.

GPUs are typically capable of handling instructions for computer graphics. Due to the advances in GPU hardware performance, GPUs can perform parallel calculations rather than computer graphics processing. The General-Purpose Computing on Graphics Process Units (GPGPU) model can provide a programming interface for performing general computer operations on the GPU.

The kernel can refer to the program unit that the GPU computes, and the kernel can perform computations on the GPU hardware.

Unlike the CPU (Central Processing Unit), the GPU may not provide GPGPU instruction scheduling in the operating system. Therefore, the GPU may depend on the device driver and hardware architecture provided by the GPU hardware.

In addition, the GPU can operate in a non-preemptive manner when GPGPU instructions are being executed on the GPU, which can not process other GPGPU commands until the end of the calculation. These characteristics make it difficult for the GPU to configure an environment capable of providing continuous resources in a multitasking environment.

Since the existing GPU management method provides the GPU instruction by modifying the device driver, it may be difficult to apply it to the GPU vendor not providing the device driver. Also, since the existing GPU management method schedules the GPU resources on a program-by-program basis, it may not be considered that a plurality of users use the GPU resources.

The existing GPU resource management method, TimeGraph, can be implemented as a centralized management method. Centralized management allows GPU commands that all processes request to be delivered to modules acting as servers and managed by a single wait queue. Because of this, the centralized management approach may incur the overhead of transferring GPU instructions to the server module.

In addition, the centralized management method can wait for the next process to be performed by the host CPU until the requested GPU command is terminated. Therefore, the centralized management method can waste CPU resources.

The GPU resource management device 10 can perform GPU resource restriction using the GPGPU technology. The GPU resource management device 10 can manage the GPU resources used by the individual processes without using the centralized management method.

The GPU resource management device 10 can periodically measure the usage time of the GPU hardware resources used by the process. The GPU resource management device 10 can compare the GPU resource usage time with the allowed usage time to limit the GPU resource usage of the process when the reserved resource is used in excess and allow other processes to use the GPU resource.

The GPU resource management apparatus 10 does not need to transmit the GPU command to the server module, so that it is possible to avoid additional overhead unlike the centralized management method. In addition, since the GPU resource management apparatus 10 operates asynchronously so as to execute the next command without waiting for a process until the end of the GPU command, the efficiency of the host CPU can be increased.

In addition, the GPU resource management device 10 can group GPU resources into task groups on a user-by-user basis and schedule GPU resources. The GPU resource management apparatus 10 can provide general scheduling of resources at a library end rather than a device driver, thus being not dependent on a GPU vendor, and having versatility.

The GPU resource management device 10 can manage resources of the GPU on a task group basis and can provide a task group management model on a user basis.

The GPU resource management device 10 can be implemented inside or outside the CPU.

The GPU resource management device 10 may include a controller 100.

The controller 100 may schedule the resource of the GPU on a time basis, measure the resource usage time, and schedule the resource based on the usage time.

Fig. 2 shows an example of the structure of the GPU resource management apparatus shown in Fig.

Referring to FIG. 2, the GPU resource management device 10 may include three components represented in a dotted box. That is, the GPU resource management device 10 may include a resource reservation interface, a kernel event and execution manager, and a GPU resource scheduler.

The resource reservation interface can provide an interface to schedule GPU resources on a user-by-user basis. The kernel event and execution manager can help measure the usage time of GPU resources, and can actually handle the GPGPU kernel execution. The GPU resource scheduler can schedule GPU resources using the time information that the user uses.

The GPU resource management apparatus 10 can hook up and implement an interface library provided by the GPGPU programming model. Thus, each process can be executed including a library provided by the system.

Figure 3 shows a schematic block diagram of the controller shown in Figure 1;

Referring to FIG. 3, the controller 100 may include a resource reservation unit 110, a usage time meter 130, and a scheduler 150.

The resource reservation unit 110 can reserve resources of the GPU on a time basis. The resource reservation unit 110 may include the resource reservation interface of FIG. The operation of the resource reservation unit 110 will be described in detail with reference to FIG.

The use time meter 130 can measure the use time of the resource. The use time meter 130 may insert an event for measuring the execution time of the kernel at the start and end of the kernel executed by the GPU and measure the execution time using the event.

The usage time meter 130 may include the kernel event and execution manager of FIG. Usage time meter 130 may use events to measure GPU run kernel time. For example, the usage time meter 130 may measure the usage time using an event provided in the Compute Unified Device Architecture (CUDA) programming interface.

An event can mean a tool that can be used to code the execution time of the kernel by injecting code between the kernels.

The use time meter 130 may analyze the schedulability and determine whether to run the GPGPU kernel based on the analysis results. The use time meter 130 hooks a function that executes a kernel, inserts a start event before a function that executes the kernel, and inserts a termination event after a function that executes the kernel. The usage time meter 130 may measure the usage time of the resources of the GPU by calculating the time between the end event and the start event.

The use time meter 130 periodically invokes an event registered in the kernel event manager and can confirm whether a registered end event per kernel has been executed. If the termination event is executed, it means that the operation is completed. Therefore, the use time meter 130 can calculate the use time of the kernel with the start event and the end event of the kernel in which the termination event is executed.

The use time meter 130 can track inserted events by managing kernel-specific events using a linked list data structure.

The use time meter 130 can check whether it is necessary to restrict the use of GPU resources before executing the kernel. If the kernel can not be executed in the current cycle, the use time meter 130 can wait for the next cycle. If the kernel can be run in the current cycle, the use time meter 130 may initialize the start and end events for kernel time measurement and register the kernel event manager and execute the kernel.

The use time meter 130 may measure the use time using a separate thread. When the host program is executed to check the GPU resource time, the use time meter 130 can generate and confirm a separate thread. For example, the usage time meter 130 may execute a thread for each user's scheduled period using a timer provided by Linux.

Scheduler 150 may schedule resources based on usage time. The scheduler 150 may include the GPU resource scheduler of FIG. The operation of the scheduler 150 will be described in detail with reference to FIG.

Fig. 4 shows an example of the structure of the resource reservation unit shown in Fig.

Referring to FIG. 4, the resource reserving unit 110 may determine whether to reserve a resource using a resource utilization rate based on a resource management period of the GPU and a resource availability period per resource management period.

The resource scheduler 110 may reserve a GPU resource use time to be used for each user. The resource reservation unit 110 may record the amount of use of the GPU in order to confirm the usage amount of the user's GPU in the process operated by the user. The resource scheduler 110 can check whether scheduling is possible with a given period and a time to be used for each user.

The resource reserving unit 110 may refuse the resource reservation if scheduling is impossible. The resource reservation unit 110 may output the reservation information to the scheduler 150. [ The reservation information may include a given period and a time to be used for each user.

The resource scheduler 110 may store an overrun time used for a plurality of users in excess of a resource management cycle, a resource availability time, a total resource usage time, and a GPU reservation time.

The resource reservation unit 110 may be implemented using sysfs provided by Linux.

The resource reservation unit 110 may have a hierarchical file structure. The resource scheduler 110 may dynamically create or remove the users directory internally. The resource reservator 110 may include a config directory, and the config directory may include init and destroy files for configuring a resource reservation interface.

The resource scheduler 110 may create and manage a directory based on a user ID (uid) so that resources can be reserved for each user through the users directory.

The resource scheduler 110 can create a user ID directory in the users directory and create a file for resource reservation by writing the user ID in the init file in the config directory. The resource scheduler 110 can delete the user ID directory existing in the users directory by using the user ID to be deleted in the destroy file.

The user identity directory may include period, quota, total_runtime, and overrun files for resource reservation. The resource scheduler 110 may store a GPU resource management period in a period and store a time in which a GPU resource can be used every cycle in a quota.

The resource scheduler 110 may store the total GPU resource time used by the user in the total_runtime file. The resource reservation unit 110 can make the total_runtime read-only and prevent the other value from being set. The resource reservoir 110 may store in the overrun file the time that the user spent excessively in the reserved resource.

The resource reservoir 110 may analyze the schedulability when reserving GPU resources. The resource reservation unit can check whether the sum of the GPU resource reservation time of other users does not exceed 100%.

The resource reservation unit 110 may calculate the resource utilization rate of the GPU. For example, the resource reservation unit 110 may calculate the resource utilization U _u of a user having a specific uid (u) as shown in Equation (1).

Here, Q _u may denote the quota of the user uid (u), and P _u may denote the use period of the user uid (u).

The resource scheduler 110 can perform the operation of Equation (1) by cyclically searching the hierarchical structure and reading the period and the quota file. At this time, the resource reservation unit 110 when checks whether ΣU _u ≤100%, the test passes, ie, it can be done successfully if the resource reservation _{U u} less than 100%.

Figure 5 shows a schematic block diagram of the scheduler shown in Figure 3;

Referring to FIG. 5, the scheduler 150 sums the usage time and determines whether to run the kernel in this period based on the reservation time for the GPU, the available time of the GPU, and the usage time before this cycle of the GPU .

The scheduler 150 is executed every cycle set by the user. The scheduler 150 loads a list of kernel events managed by the kernel event manager each time it is executed, and can sum up all the GPU usage times of the kernel. Accordingly, the scheduler 150 can schedule the GPU resources by determining whether or not the GPU resources can be used in this period based on the time reserved by the user.

The scheduler 150 may schedule resources for each resource management cycle of the GPU. The scheduler 150 can determine whether to execute the kernel in this cycle by calculating the usage time of the kernel used up to this time with the time reserved by the user. The scheduler 150 may calculate a quota to be used in the next cycle.

The scheduler 150 may include at least one of an overrun detector 151, a first comparator 153, a second comparator 155, a third comparator 157 and a determiner 159.

The overrun determiner 151 may determine whether there is an overrun time in excess of the reserved time for the GPU.

The first comparator 153 may compare the overrun time and the reserved time first. The second comparator 155 may compare the use time and the usable time before this cycle secondly. The third comparator 157 may compare the overrun time and the usable time third.

The determiner 159 may update the available time and overrun time based on the existence of the overrun time, the first comparison result, the second comparison result, and the third comparison result, and determine whether to execute the kernel.

6 shows an example of a flow chart of the operation of the scheduler shown in Fig.

Referring to FIG. 6, variables can be defined as shown in Table 1.

variable Justice Q _u User-reserved quota, reserved time for GPU CQ _u The quota the user can use in this cycle, the available time of the GPU, and initially the Q _u value P _u The user-scheduled period, the GPU resource management cycle CP _u Whether the user can run the GPGPU kernel in this cycle KT _{u, i} The usage time of the i-th GPGPU kernel that the user executed before this cycle KT _u The total usage time of the GPGPU kernel that the user executed before this cycle, the usage time before this cycle of the GPU KO _u Time spent using GPGPU kernel exceeding user quota, overrun time exceeding reserved time for GPU CO _u The amount of time that the GPGPU kernel has been running since the user's scheduled time in this cycle

The scheduler 150 can measure the total usage time (KT _u ) of the GPGPU kernel used up to this time and schedule the GPU resources. The scheduler 150 can calculate the total usage time of the GPGPU kernel used up to this time as Equation (2).

Here, N may mean the number of GPGPU kernels that have been executed before this cycle.

Referring to FIG. 6A, the overrun determinator 151 may determine whether KO _u is greater than zero. That is, the overrun determinator 151 can determine whether the overrun time is present by determining whether the overrun time is a positive number.

If KO _u is greater than zero, the first comparator 153 may compare KO _u and Q _u . In the first comparison, if KO _u is less than Q _u , it means that the GPU resource time used before this cycle used more GPU resources than the reserved time, but there is time available for GPU resources in this cycle have. In this case, the determiner 159 may set the CP _u value to true so that the GPU kernel can be used during this period, except for the more used time at the scheduled time.

If the first comparison shows that KO _u is greater than Q _u , it may mean that there is no GPU resource time available for this period. In this case, since the GPU needs to relax one cycle, the determiner 159 can set the CP _u value to false except for the Q _u value at KO _u .

FIG. 6 (b) shows the case where there is no overrun time, that is, when KO _u is zero. In this case, it may mean that the used GPU resource time before this period is used within the reserved time.

The second comparator can compare KT _u with CQ _u . As a result of the second comparison, if the value of KT _u is smaller than CQ _u , it means that the GPGPU use time before this cycle is within a given time. Therefore, the determiner 159 can initialize the usable time for this cycle to a time reserved by the user, and set the CP _u value to true so that the GPGPU kernel can be executed in this cycle.

As a result of the second comparison, if the value of KT _u is larger than CQ _u , it means that the GPGPU use time of the used kernel before this cycle is longer than the given time. In this case, the determiner 159 may perform the calculation as in Equation 3 to determine whether the process can use the GPGPU resource in this cycle.

After the calculation of Equation (3) is performed, the third comparator (157) can compare the value of KO _u with CQ _u . As a result of the third comparison, if the value of KO _u is smaller than CQ _u , the determiner 159 can set the CP _u value to true so that the GPGPU kernel can be executed except for the time used in the present cycle have.

As a result of the third comparison, if the value of KO _u is larger than CQ _u , it means that more time is used than the available time in this cycle. In this case, the determiner 159 may set the CP _u value to false so that the GPGPU kernel can not be executed in this cycle. Further, since the GPU does not execute the kernel in this period, the determiner 159 can exclude the time CQ _u that can be used in this cycle from the value of KO _u .

The determiner 159 may determine, according to the CP _u value calculated in the GPU resource scheduler, to wake up the process waiting for the next cycle. The waking process can determine whether or not the kernel is executed according to the CP _u value.

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 apparatus and components described in the embodiments may be implemented within a computer system, such as, for example, a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA) , 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 execution of the software. For ease of understanding, the processing apparatus may be described as being used singly, but those skilled in the art will recognize that the processing apparatus may have a plurality of processing elements and / As shown in FIG. For example, the processing unit may comprise a plurality of processors or one processor and one controller. Other processing configurations are also possible, such as a parallel processor.

The software may include a computer program, code, instructions, or a combination of one or more of the foregoing, and may be configured to configure the processing device to operate as desired or to process it collectively or collectively Device can be commanded. The software and / or data may be in the form of any type of machine, component, physical device, virtual equipment, computer storage media, or device , Or may be permanently or temporarily embodied in a transmitted signal wave. The software may be distributed over a networked computer system and stored or executed in a distributed manner. The software and data may be stored on one or more computer readable recording media.

The method according to an embodiment may be implemented in the form of a program command that can be executed through various computer means and recorded in a computer-readable medium. The computer-readable medium may include program instructions, data files, data structures, and the like, alone or in combination. The program instructions to be recorded on the medium may be those specially designed and configured for the embodiments or may be available to those skilled in the art of computer software. Examples of computer-readable media include magnetic media such as hard disks, floppy disks and magnetic tape; optical media such as CD-ROMs and DVDs; magnetic media 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 machine language code such as those produced by a compiler, as well as high-level language code that can be executed by a computer using an interpreter or the like. The hardware devices described above may be configured to operate as one or more software modules to perform the operations of the embodiments, and vice versa.

While the present invention has been particularly shown and described with reference to exemplary embodiments thereof, it is to be understood that the invention is not limited to the disclosed exemplary embodiments. For example, it is to be understood that the techniques described may be performed in a different order than the described methods, and / or that components of the described systems, structures, devices, circuits, Lt; / RTI > or equivalents, even if it is replaced or replaced.

Therefore, other implementations, other embodiments, and equivalents to the claims are also within the scope of the following claims.

Claims (17)

The GPU resource management apparatus reserving resources of the GPU on a time basis;
Measuring a usage time of the resource by the GPU resource management device; And
Wherein the GPU resource management device schedules the resource based on the usage time
Lt; / RTI >
Wherein the scheduling comprises:
Summing the usage time; And
Determining whether to execute the kernel in this cycle based on a reservation time for the GPU, a usable time of the GPU, and a usage time before the current cycle of the GPU
Lt; / RTI >
Wherein the determining comprises:
Determining whether there is an overrun time in excess of the reserved time for the GPU;
Comparing the overrun time and the reserved time first;
Comparing the use time before the current cycle and the available time second;
Comparing the overrun time and the available time third; And
Updating the usable time and the overrun time based on the existence of the overrun time, the first comparison result, the second comparison result, and the third comparison result, and determining whether to execute the kernel
Gt; GPU < / RTI >
The method according to claim 1,
Wherein the step of reserving comprises:
Determining whether to reserve the resource using the resource utilization rate based on the resource management period of the GPU and the available time of the resource per the resource management period;
Gt; GPU < / RTI >
3. The method of claim 2,
Wherein the step of reserving comprises:
Storing the overrun time used for the plurality of users in excess of the resource management period, the available time of the resource, the total usage time of the resource, and the reservation time for the GPU
The GPU resource management method further comprising:
The method according to claim 1,
Wherein the measuring step comprises:
Inserting an event for measuring the execution time of the kernel at the start and end of a kernel executed by the GPU; And
Measuring the execution time using the event
Gt; GPU < / RTI >
delete delete The method according to claim 1,
Wherein the scheduling comprises:
Scheduling the resource for each resource management cycle of the GPU
How to manage GPU resources.
The method according to claim 1,
Wherein the measuring step comprises:
The use time is measured by using a separate thread
How to manage GPU resources.
A controller that reserves a resource of the GPU on a time basis, measures the use time of the resource, and schedules the resource based on the usage time,
Lt; / RTI >
The controller comprising:
A scheduler for scheduling the resource based on the usage time;
Lt; / RTI >
Wherein the scheduler sums the use time,
An overrun determinator for determining whether there is an overrun time in excess of the reserved time for the GPU;
A first comparator for comparing the overrun time and the reserved time first;
A second comparator for comparing a usage time before the current cycle of the GPU and a usable time of the GPU;
A third comparator for comparing the overrun time and the usable time third; And
A determiner for updating the usable time and the overrun time based on the existence of the overrun time, the first comparison result, the second comparison result, and the third comparison result, and determining whether to execute the kernel;
The GPU resource management apparatus comprising:
10. The method of claim 9,
The controller comprising:
A resource reservation unit for reserving resources of the GPU on a time basis; And
A use time meter for measuring the use time of the resource
The GPU resource management apparatus further comprising:
11. The method of claim 10,
Wherein the resource reservation unit comprises:
The resource utilization rate based on the resource management period of the GPU and the available time of the resource per the resource management period is used to determine whether to reserve the resource
GPU resource management device.
12. The method of claim 11,
Wherein the resource reservation unit comprises:
Storing the overrun time used for the plurality of users in excess of the resource management period, the available time of the resource, the total usage time of the resource, and the reserved time for the GPU
GPU resource management device.
11. The method of claim 10,
Wherein the use time meter comprises:
An event for measuring the execution time of the kernel is inserted at the start and end of a kernel executed by the GPU, and the execution time is measured using the event
GPU resource management device.
delete delete 10. The method of claim 9,
The scheduler comprising:
Scheduling the resource for each resource management cycle of the GPU
GPU resource management device.
11. The method of claim 10,
Wherein the use time meter comprises:
The use time is measured by using a separate thread
GPU resource management device.

Images