Resource allocation method and device, electronic equipment and storage medium

Abstract

The invention provides a resource allocation method and device, electronic equipment and a storage medium. Relates to the technical field of computers. The method comprises the following steps: determining a target task to be processed by a target virtual machine, wherein the target virtual machine and at least one other virtual machine share resources of an image processor GPU; according to the target task, determining a target occupation duration required by the target virtual machine for the GPU; according to the target occupation duration, a resource allocation request is sent to a resource calling device corresponding to the GPU, and the resource allocation request is used for requesting to allocate GPU resources corresponding to the target occupation duration for the target virtual machine. According to the scheme, the resource utilization rate of the GPU is improved.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to a resource allocation method, device, electronic device, and storage medium. Background Art

[0002] Virtual machines can utilize the resources of a graphics processing unit (GPU) to meet the running requirements of different tasks. In some scenarios, multiple virtual machines can share a single GPU resource. Therefore, GPU resources need to be allocated to multiple virtual machines.

[0003] In related technologies, for at least one virtual machine sharing the same GPU resources, each virtual machine has a consistent access duration for accessing the GPU. When accessing the GPU, any virtual machine sends an access request to the GPU hardware resource scheduling module. Upon receiving the access request, the GPU hardware resource scheduling module allocates GPU resources to the virtual machine within the access duration if the GPU is idle. However, allocating GPU resources to virtual machines using this method results in low GPU resource utilization. Summary of the Invention

[0004] The present application provides a resource allocation method, device, electronic device, and storage medium for improving GPU resource utilization.

[0005] In a first aspect, the present application provides a resource allocation method, the method comprising:

[0006] Determine a target task to be processed by a target virtual machine, where the target virtual machine shares resources of a graphics processing unit (GPU) with at least one other virtual machine;

[0007] Determine the target GPU occupancy time required by the target virtual machine based on the target task;

[0008] According to the target occupancy time, a resource allocation request is sent to the resource calling device corresponding to the GPU. The resource allocation request is used to request allocation of GPU resources corresponding to the target occupancy time for the target virtual machine.

[0009] In one possible implementation, determining a target GPU occupancy time required by a target virtual machine based on a target task includes:

[0010] Get the task information of the target task, including the task size and target task type;

[0011] Obtain multiple historical resource allocation records of the target virtual machine, including historical task size, historical task type, historical GPU occupancy time, and historical allocation time;

[0012] Determine the target occupancy time based on task information and / or multiple historical resource allocation records.

[0013] In a possible implementation, determining the target occupancy time according to the task information includes:

[0014] Determining a first occupied duration according to the task size and a first corresponding relationship, wherein the first corresponding relationship includes a plurality of task size intervals and an occupied duration corresponding to each task size interval;

[0015] Determining a target weight coefficient according to the target task type and a second corresponding relationship, wherein the second corresponding relationship includes multiple task types and weight coefficients corresponding to each task type;

[0016] The product of the first occupation time and the target weight coefficient is determined as the target occupation time.

[0017] In a possible implementation, determining the target occupancy duration based on multiple historical resource allocation records includes:

[0018] Determine the execution time of the target task;

[0019] determining a first time difference between the execution time and the start time of the current cycle;

[0020] For any historical resource allocation record, determining a second time difference between a historical allocation time in the historical resource allocation record and a start time of a corresponding period;

[0021] Determining, based on the first time difference and the second time difference corresponding to each historical resource allocation record, at least one first allocation record from the plurality of historical resource allocation records, wherein a difference between the second time difference corresponding to the first allocation record and the first time difference is less than or equal to a preset threshold;

[0022] A target GPU occupancy duration is determined according to a historical GPU occupancy duration in the at least one first allocation record.

[0023] In one possible implementation, determining the target occupancy duration based on task information and multiple historical resource allocation records includes:

[0024] Determine a first eigenvector corresponding to the task information;

[0025] For any historical resource allocation record, generate a second feature vector corresponding to the historical resource allocation record according to the historical task size and historical task type in the historical resource allocation record;

[0026] determining at least one second allocation record from a plurality of historical resource allocation records according to the first eigenvector and the second eigenvector;

[0027] The target GPU occupancy duration is determined according to the historical GPU occupancy duration in the at least one second allocation record.

[0028] In a possible implementation, sending a resource allocation request to a resource calling device corresponding to the GPU according to the target occupancy duration includes:

[0029] Generate a resource allocation request according to the target occupancy time, where the resource allocation request includes the target occupancy time;

[0030] Determine the target transmission mode, which can be cross-domain communication or shared memory;

[0031] Send a resource allocation request to the resource calling device through the target transmission mode.

[0032] In one possible implementation, the method further includes:

[0033] Receive a resource allocation response sent by the resource calling device, where the resource allocation response includes a target time period, and the duration of the target time period is the target occupancy time period;

[0034] During the target period, the GPU is called to execute the target task.

[0035] In a second aspect, the present application provides a resource allocation device, comprising:

[0036] a determination module, configured to determine a target task to be processed by a target virtual machine, where the target virtual machine shares resources of a graphics processing unit (GPU) with at least one other virtual machine;

[0037] A processing module is used to determine a target occupancy time required by a target virtual machine on a GPU according to a target task;

[0038] The sending module is used to send a resource allocation request to the resource calling device corresponding to the GPU according to the target occupancy time. The resource allocation request is used to request allocation of GPU resources corresponding to the target occupancy time for the target virtual machine.

[0039] In a possible implementation, the processing module is specifically configured to:

[0040] Get the task information of the target task, including the task size and target task type;

[0041] Obtain multiple historical resource allocation records of the target virtual machine, including historical task size, historical task type, historical GPU occupancy time, and historical allocation time;

[0042] Determine the target occupancy time based on task information and / or multiple historical resource allocation records.

[0043] In a possible implementation, the processing module is specifically configured to:

[0044] Determining a first occupied duration according to the task size and a first corresponding relationship, wherein the first corresponding relationship includes a plurality of task size intervals and an occupied duration corresponding to each task size interval;

[0045] Determining a target weight coefficient according to the target task type and a second corresponding relationship, wherein the second corresponding relationship includes multiple task types and weight coefficients corresponding to each task type;

[0046] The product of the first occupation time and the target weight coefficient is determined as the target occupation time.

[0047] In a possible implementation, the processing module is specifically configured to:

[0048] Determine the execution time of the target task;

[0049] determining a first time difference between the execution time and the start time of the current cycle;

[0050] For any historical resource allocation record, determining a second time difference between a historical allocation time in the historical resource allocation record and a start time of a corresponding period;

[0051] Determining, based on the first time difference and the second time difference corresponding to each historical resource allocation record, at least one first allocation record from the plurality of historical resource allocation records, wherein a difference between the second time difference corresponding to the first allocation record and the first time difference is less than or equal to a preset threshold;

[0052] A target GPU occupancy duration is determined according to a historical GPU occupancy duration in the at least one first allocation record.

[0053] In a possible implementation, the processing module is specifically configured to:

[0054] Determine a first eigenvector corresponding to the task information;

[0055] For any historical resource allocation record, generate a second feature vector corresponding to the historical resource allocation record according to the historical task size and historical task type in the historical resource allocation record;

[0056] determining at least one second allocation record from a plurality of historical resource allocation records according to the first eigenvector and the second eigenvector;

[0057] The target GPU occupancy duration is determined according to the historical GPU occupancy duration in the at least one second allocation record.

[0058] In a possible implementation, the sending module is specifically configured to:

[0059] Generate a resource allocation request according to the target occupancy time, where the resource allocation request includes the target occupancy time;

[0060] Determine the target transmission mode, which can be cross-domain communication or shared memory;

[0061] Send a resource allocation request to the resource calling device through the target transmission mode.

[0062] In one possible implementation, the device further includes:

[0063] Receive a resource allocation response sent by the resource calling device, where the resource allocation response includes a target time period, and the duration of the target time period is the target occupancy time period;

[0064] During the target period, the GPU is called to execute the target task.

[0065] In a third aspect, the present application provides an electronic device, comprising:

[0066] at least one processor; and

[0067] a memory communicatively connected to at least one processor; wherein,

[0068] The memory stores instructions that can be executed by at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to perform the resource allocation method involved in the first aspect and any possible implementation manner.

[0069] In a fourth aspect, the present application provides a non-transitory computer-readable storage medium, wherein the computer-readable storage medium stores computer execution instructions, and the computer execution instructions are used to enable a computer to execute the resource allocation method involved in the first aspect and any possible implementation method.

[0070] In a fifth aspect, the present application provides a computer program product, including a computer program, which, when executed by a processor, implements the resource allocation method involved in the first aspect and any possible implementation method.

[0071] In a sixth aspect, the present application provides a chip, the chip comprising at least one processor, the processor being configured to run program instructions to execute the resource allocation method involved in the first aspect and any possible implementation manner.

[0072] The resource allocation method, device, electronic device, and storage medium provided in the embodiments of the present application first determine the target task to be processed by the target virtual machine, and based on the target task, determine the target occupancy time required by the target virtual machine for the GPU, and then send a resource allocation request to the resource calling device corresponding to the GPU, requesting the resource calling device to allocate GPU resources corresponding to the target occupancy time to the target virtual machine. Through the above method, the target virtual machine determines the target occupancy time required by the target virtual machine for the GPU when processing the target task based on the target task to be processed, and then requests the resource calling device to allocate GPU resources corresponding to the target occupancy time to the target virtual machine, thereby improving the resource utilization of the GPU. BRIEF DESCRIPTION OF THE DRAWINGS

[0073] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present application and, together with the description, serve to explain the principles of the present application.

[0074] Figure 1 Schematic diagram of application scenarios provided by embodiments of the present application;

[0075] Figure 2 A schematic diagram of a resource allocation method according to an embodiment of the present invention;

[0076] Figure 3 A schematic diagram of a process for determining target occupancy time provided in an embodiment of the present application;

[0077] Figure 4 A signaling diagram of a resource allocation method provided in an embodiment of the present application;

[0078] Figure 5 A schematic diagram of the structure of a resource allocation device provided in an embodiment of the present application;

[0079] Figure 6 A schematic diagram of the structure of an electronic device provided in an embodiment of the present application.

[0080] The above drawings illustrate specific embodiments of the present application, which will be described in more detail below. These drawings and the textual description are not intended to limit the scope of the present application in any way, but rather to illustrate the concepts of the present application to those skilled in the art by reference to specific embodiments. DETAILED DESCRIPTION

[0081] Exemplary embodiments will be described in detail herein, with examples illustrated in the accompanying drawings. In the following description, when referring to the drawings, identical numerals in different figures represent identical or similar elements, unless otherwise indicated. The embodiments described in the following exemplary embodiments are not intended to represent all embodiments consistent with the present application. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the present application, as detailed in the appended claims.

[0082] In the technical solution of this application, the collection, storage, use, processing, transmission, provision and disclosure of information such as financial data or user data involved comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

[0083] It should be noted that in the embodiments of the present application, certain software, components, models and other existing solutions in the industry may be mentioned. They should be regarded as exemplary. Their purpose is only to illustrate the feasibility of implementing the technical solution of the present application, but it does not mean that the applicant has or will necessarily use the solution.

[0084] For ease of understanding, the following Figure 1 , briefly describe the application scenarios to which the embodiments of the present application are applicable.

[0085] Figure 1 This is a schematic diagram of the application scenario provided by the embodiment of this application. Figure 1 , including a virtual machine 11, a resource calling device 12 and a GPU 13.

[0086] In actual use, virtual machine 11 can communicate with resource calling device 12 through the virtual machine hypervisor. For example, virtual machine 11 sends a resource allocation request to resource calling device 12 through the virtual machine hypervisor, and resource calling device 12 sends a resource allocation response to virtual machine 11 through the virtual machine hypervisor. In addition, resource calling device 12 is responsible for allocating GPU 13 resources to virtual machine 11. For example, after receiving the resource allocation request sent by virtual machine 11, resource calling device 12 allocates GPU 13 resources to virtual machine 11 when GPU 13 is idle.

[0087] It should be noted that Figure 1 This is just an example to illustrate an application scenario, and is not intended to limit the application scenario.

[0088] In related technologies, virtual machines can share GPU resources in ways that include shared access methods based on graphics application programming interface (API) forwarding, direct access methods, hardware virtualization methods, and paravirtualization methods. The shared access methods for graphics API forwarding include a graphics API server partition and a graphics API client partition, where the graphics API server partition includes GPU hardware and image driver software, and the graphics API client partition includes graphics API forwarding software and graphics application software. When the graphics application software in the graphics API client partition needs to execute a graphics task, it calls the graphics API. After the graphics API forwarding software captures the graphics API call, it sends the graphics API to the graphics API server partition in accordance with the agreed protocol. After receiving the graphics API, the graphics driver software in the graphics API server partition parses and executes the graphics task, and returns the execution result to the graphics API client partition after execution is completed. However, in the above method, since the graphics task needs to be forwarded between the graphics API client and the graphics API server, the large amount of data during the forwarding process will result in a high delay in task processing.

[0089] Hardware virtualization integrates a graphics virtualization manager with the GPU, allowing administrators to configure multiple virtual GPUs within the manager. This allows for hardware-based resource isolation between multiple partitions. It's important to note that the operating principles of these virtual GPUs on the processor cores are the same as those of standalone GPUs. However, this method requires a platform that supports GPU hardware virtualization.

[0090] The passthrough method involves setting up an external interconnect interface on the GPU device that can connect to virtual machines. In this case, the virtual machine can connect to the GPU device through the external interconnect interface and access GPU resources. However, in this method, each GPU device is only accessible to one virtual machine, and multiple virtual machines cannot share the same GPU resources.

[0091] Paravirtualization modifies the guest operating system's graphics driver, allowing the virtual machine to interact directly with the hypervisor. The hypervisor then sends resource allocation requests to the resource calling device. If the GPU is idle, the resource calling device allocates GPU resources to the virtual machine within a preset access duration. However, due to the varying size and type of tasks performed by virtual machines, the duration of GPU resource usage varies. Therefore, allocating GPU resources to a virtual machine within the preset access duration results in low GPU resource utilization.

[0092] Based on this, the resource allocation method provided in an embodiment of the present application determines the target GPU occupancy duration required by the target virtual machine based on the target task of the target virtual machine, and then sends a resource allocation request to a resource calling device. When the GPU is idle, the resource calling device allocates GPU resources corresponding to the target occupancy duration to the target virtual machine, thereby improving GPU resource utilization.

[0093] The following specific embodiments describe in detail the technical solution of the present application and how the technical solution of the present application solves the above-mentioned technical problems. The following specific embodiments can be combined with each other, and the same or similar concepts or processes may not be repeated in some embodiments. The embodiments of the present application will be described below in conjunction with the accompanying drawings.

[0094] Figure 2 This is a flow chart of a resource allocation method provided in an embodiment of the present application. Figure 2 , the method may include the following steps:

[0095] S21 : Determine a target task to be processed by a target virtual machine, where the target virtual machine shares GPU resources with at least one other virtual machine.

[0096] The execution subject of the embodiment of the present application can be the target virtual machine, or can be a resource allocation device set in the target virtual machine. The resource allocation device can be implemented by software, or by a combination of software and hardware.

[0097] The target virtual machine may be a virtual machine among multiple virtual machines sharing GPU resources, whose GPU resource occupation time is to be determined. The target task may be a task that the target virtual machine needs to process at the current moment.

[0098] For example, assume that the virtual machines sharing GPU resources are VM 1, VM 2, and VM 3, respectively. The task VM 1 currently needs to process is Task A, the task VM 2 currently needs to process is Task B, and the task VM 3 currently needs to process is Task C. If the target virtual machine is VM 1, then the target task to be processed by the target virtual machine is determined to be Task A.

[0099] S22. Determine the target occupancy time required by the target virtual machine on the GPU according to the target task.

[0100] The target duration is the length of time the target VM needs to occupy GPU resources when processing the target task. The target duration can be expressed in units such as microseconds, nanoseconds, and milliseconds.

[0101] Depending on the size of the target task and the usage scenario, the target VM will need to occupy GPU resources for different periods of time when processing the target task. This means that the target VM's target occupation time on the GPU will vary depending on the target task. Generally, the larger the target task, the longer the target VM's GPU occupation time will be. The more demanding the target task's usage scenario, the longer the target VM's GPU occupation time will be. Specifically, the target GPU occupation time required by the target VM can be determined by comprehensively considering factors such as the target task's size and usage scenario.

[0102] For example, for Task A and Task B, assuming Task A is used in an in-vehicle device, has a video drawing task type and a task size of 30MB; Task B is used in a wearable device, has a page switching task type and a task size of 2MB. When Task A is the target task, the target VM's GPU usage duration is determined to be 20 nanoseconds based on Task A. When Task B is the target task, the target VM's GPU usage duration is determined to be 10 microseconds based on Task B.

[0103] S23. Send a resource allocation request to a resource calling device corresponding to the GPU according to the target occupancy time. The resource allocation request is used to request allocation of GPU resources corresponding to the target occupancy time for the target virtual machine.

[0104] The resource calling device corresponding to the GPU is used to call and allocate GPU resources. After receiving a resource allocation request from a virtual machine, the resource calling device allocates GPU resources corresponding to the target occupancy duration to the target virtual machine. For example, for virtual machine 1 and virtual machine 2, virtual machine 1's target GPU occupancy duration is M, and virtual machine 2's target GPU occupancy duration is N. When the resource calling device receives a resource allocation request from virtual machine 1, it allocates the GPU resources corresponding to the target occupancy duration M to virtual machine 1. When the resource calling device receives a resource allocation request from virtual machine 2, it allocates the GPU resources corresponding to the target occupancy duration N to virtual machine 2.

[0105] The resource allocation method provided in an embodiment of the present application first determines the target task to be processed by the target virtual machine, and based on the target task, determines the target occupancy time required by the target virtual machine for the GPU, and then sends a resource allocation request to the resource calling device corresponding to the GPU, requesting the resource calling device to allocate GPU resources corresponding to the target occupancy time to the target virtual machine. Through the above method, the target virtual machine determines the target occupancy time required by the target virtual machine for the GPU when processing the target task based on the target task to be processed, and then requests the resource calling device to allocate GPU resources corresponding to the target occupancy time to the target virtual machine, thereby improving GPU resource utilization.

[0106] exist Figure 2 Based on the embodiment shown below, combined with Figure 3 The process of determining the target occupancy time required by the target virtual machine on the GPU according to the target task is described in detail.

[0107] Figure 3 This is a flow chart of determining target occupancy time provided by an embodiment of the present application. Figure 3 , the method may include the following steps:

[0108] S31. Obtain task information of the target task, where the task information includes task size and target task type.

[0109] Task information is used to indicate relevant information about the target task. Task size can be the size of the target task. For example, if the target task size is 3MB, then the target task size is 3MB. The target task type is used to indicate the usage scenario and task category of the target task. For example, if Task A is used for wearable devices and its task category is page drawing, and Task B is used for in-vehicle devices and its task category is video drawing. When the target task is Task A, the target task type is a page drawing task for wearable devices; when the target task is Task B, the target task type is a video drawing task for in-vehicle devices.

[0110] S32: Acquire multiple historical resource allocation records of the target virtual machine, where the historical resource allocation records include historical task size, historical task type, historical GPU occupancy time, and historical allocation time.

[0111] The multiple historical resource allocation records are used to represent multiple historical tasks for the target virtual machine, task information of each historical task, and the duration and allocation time of GPU resources allocated to each historical task.

[0112] For any historical task among the multiple historical tasks of the target virtual machine, the historical task size of the historical task is the size of the historical task, the historical task type is used to indicate the usage scenario and task category of the historical task, the historical GPU occupancy time is used to indicate the length of time the target virtual machine occupies GPU resources when executing the historical task, and the historical allocation time is used to indicate the time when the resource calling device allocates GPU resources to the target virtual machine when the target virtual machine executes the historical task.

[0113] For example, assume that the target virtual machine has multiple historical tasks, namely Task A, Task B, and Task C. The historical task size of Task A is 10 MB, the historical task type is a video drawing task for an in-vehicle device, the historical GPU occupancy time is 10 microseconds, and the historical allocation time is time X; the historical task size of Task B is 2 MB, the historical task type is a page drawing task for a wearable device, the historical GPU occupancy time is 3 microseconds, and the historical allocation time is time Y; the historical task size of Task C is 5 MB, the historical task type is a page drawing task for a mobile device, the historical GPU occupancy time is 7 microseconds, and the historical allocation time is time Z.

[0114] Then the multiple historical resource allocation records of the target virtual machine can be shown in Table 1:

[0115] Table 1

[0116]

[0117] S33. Determine the target occupancy time based on the task information and / or multiple historical resource allocation records.

[0118] The method of determining the target occupancy time based on task information can be as follows: determine the first occupancy time based on the task size and the first corresponding relationship, the first corresponding relationship includes multiple task size intervals and the occupancy time corresponding to each task size interval; determine the target weight coefficient based on the target task type and the second corresponding relationship, the second corresponding relationship includes multiple task types and the weight coefficient corresponding to each task type; and determine the target occupancy time as the product of the first occupancy time and the target weight coefficient.

[0119] The task size interval can be a preset task size interval, for example, 0-5MB, 5-10MB, 10-15MB, etc. The first correspondence is used to represent the corresponding occupied time of the target task in different task size intervals. The first occupied time is determined based on the task size of the target task and the first correspondence, and is used to represent the occupied time corresponding to the task size of the target task. The second correspondence is used to represent the weight coefficients corresponding to different task types.

[0120] First, based on the task size of the target task, the task size interval corresponding to the target task can be determined in multiple task size intervals in the first corresponding relationship, and then the first occupied time corresponding to the target task can be determined. The first occupied time is the occupied time corresponding to the task size interval corresponding to the target task in the first corresponding relationship.

[0121] Then, according to the target task type of the target task, among the multiple task types in the second corresponding relationship, the task type that is the same as the target task type is determined, and then the target weight coefficient corresponding to the target task type is determined. The target weight coefficient is the weight coefficient corresponding to the task type that is the same as the target task type in the second corresponding relationship.

[0122] Finally, the first occupied time corresponding to the target task is multiplied by the target weight coefficient to obtain the target occupied time corresponding to the target task.

[0123] For example, assuming the target task size is 15MB and the target task type is a video drawing task for an on-board device, the first correspondence includes task size intervals of 0-10MB, 10-20MB, and 20-30MB, where the task size interval of 0-10MB corresponds to a duration of 10 microseconds, the task size interval of 10-20MB corresponds to a duration of 20 microseconds, and the task size interval of 20-30MB corresponds to a duration of 30 microseconds. The second correspondence includes multiple task types, namely, a video drawing task for an on-board device, a page drawing task for an on-board device, and a page drawing task for a wearable device, where the weight coefficients of the video drawing task for an on-board device are 50%, 30% for the page drawing task for an on-board device, and 20% for the page drawing task for a wearable device.

[0124] Based on the task size of the target task, the task size interval corresponding to the target task is determined to be 10-20MB among the multiple task size intervals in the first correspondence, and the first occupied time corresponding to the target task is determined to be 20 microseconds, the occupied time corresponding to 10-20MB in the first correspondence. Then, based on the target task type of the target task, the task type identical to the target task type is determined to be a video drawing task for an on-board device among the multiple task types in the second correspondence, and the target weight coefficient is determined to be 50% of the corresponding weight coefficient for the video drawing task on the on-board device in the second correspondence. Finally, the first occupied time of 20 microseconds is multiplied by the target weight coefficient of 50% to obtain a target occupied time of 10 microseconds.

[0125] The above method introduces a method for determining the target occupancy time based on task information. In addition, the target occupancy time can also be determined based on multiple historical resource allocation records. This method can be as follows: determine the execution time of the target task; determine the first time difference between the execution time and the start time of the current cycle; for any historical resource allocation record, determine the second time difference between the historical allocation time in the historical resource allocation record and the start time of the corresponding cycle; based on the first time difference and the second time difference corresponding to each historical resource allocation record, determine at least one first allocation record in multiple historical resource allocation records, and the difference between the second time difference corresponding to the first allocation record and the first time difference is less than or equal to a preset threshold; determine the target occupancy time based on the historical GPU occupancy time in at least one first allocation record.

[0126] The execution time of the target task is the start time of the target virtual machine processing the target task. Assuming a day is a cycle, the current cycle can be the day on which the target virtual machine processes the target task, and the start time of the current cycle can be the start time of the day on which the target virtual machine processes the target task. The first time difference can be the time difference between the execution time of the target task and the start time of the current cycle. The first time difference is used to indicate the relative position of the target task in the current cycle.

[0127] Assuming a day is a period, for any historical resource allocation record, the period corresponding to the historical resource allocation record can be the day when the target virtual machine processed the historical task corresponding to the historical resource allocation record, and the start time of the corresponding period can be the start time of the day when the target virtual machine processed the historical task. The second time difference can be the time difference between the historical allocation time and the start time of the corresponding period, and the second time difference is used to indicate the relative position of the historical task in the corresponding period.

[0128] At least one first allocation record may be a historical resource allocation record in which the difference between the first time difference and the second time difference is less than or equal to a preset threshold value among multiple historical resource allocation records, that is, the time characteristics of the historical task corresponding to the at least one first allocation record are similar to the time characteristics of the target task.

[0129] The target occupancy time may be determined based on the historical GPU occupancy time in the at least one first allocation record by calculating an average value, a median value, a maximum value, a minimum value, or other related parameters of the historical GPU occupancy time in the at least one first allocation record, and using the calculated value as the target occupancy time.

[0130] In summary, methods for determining the target occupancy time based on task information or multiple historical resource allocation records are introduced respectively. In addition, in a possible implementation manner, the target occupancy time can be determined based on the task information of the target task and multiple historical resource allocation records. This method can be as follows: determine the first eigenvector corresponding to the task information; for any historical resource allocation record, generate a second eigenvector corresponding to the historical resource allocation record based on the historical task size and historical task type in the historical resource allocation record; determine at least one second allocation record from multiple historical resource allocation records based on the first eigenvector and the second eigenvector; and determine the target occupancy time based on the historical GPU occupancy time in the at least one second allocation record.

[0131] The first feature vector includes the task size and target task type of the target task. The target task type can be expressed in digital form. For example, assuming that the task for the vehicle-mounted device is represented as 1, the task for the wearable device is identified as 2, the task for the mobile device is represented as 3, the video drawing task is represented as 0, and the page drawing task is represented as 1, then when the target task type is a video drawing task for the vehicle-mounted device, the target task type can be expressed as 1-0; when the target task type is a page drawing task for the wearable device, the target task type can be expressed as 2-1; when the target task type is a page drawing task for the mobile device, the target task type can be expressed as 3-1.

[0132] For example, assuming that the task size of the target task is 20MB and the target task type is a video drawing task for an in-vehicle device, the first feature vector can be [20, 1-0], where 20 is used to indicate that the task size of the target task is 20MB, 1-0 is used to indicate the target task type of the target task, and 1 in 1-0 is used to indicate that the usage scenario of the target task is for an in-vehicle device, and 0 is used to indicate that the task category of the target task is a video drawing task.

[0133] For any historical resource allocation record, the second feature vector corresponding to the historical resource allocation record includes the historical task size and the historical task type in the historical resource allocation record. The representation of the historical task size and the historical task type in the second feature vector is consistent with the representation of the task size and the target task type in the first feature vector. It should be noted that the position of the historical task size in the second feature vector is consistent with the position of the task size in the first feature vector; the position of the historical task type in the second feature vector is consistent with the position of the target task type in the first feature vector. For example, assuming that the first feature vector is [20, 1-0], where 20 is used to indicate that the task size of the target task is 20MB, 1-0 is used to indicate the target task type of the target task, the historical task size is 10MB, and the historical task type is represented as 2-1, then the second feature vector can be expressed as [10, 2-1]. The second allocation record is a historical resource allocation record in which the corresponding second feature vector matches the first feature vector among multiple historical resource allocation records.

[0134] First, based on the task information of the target task, the first eigenvector corresponding to the target task is determined. Then, for multiple historical resource allocation records of the target virtual machine, based on the historical task size and historical task type of each historical resource allocation record, the second eigenvector corresponding to each historical resource allocation record is determined. The first eigenvector is matched with the second eigenvector, and the historical resource allocation record corresponding to the second eigenvector that matches the first eigenvector is determined as the second allocation record, thereby obtaining at least one second allocation record. The average, median, maximum, or minimum value and other related parameters of the historical GPU occupancy time in the at least one second allocation record are calculated and determined as the target occupancy time.

[0135] For example, assuming the target task information is: the task size is 2MB, the target task type is a page drawing task for a wearable device, the first eigenvector corresponding to the target task is determined to be [2, 2-1], where 2 represents the task size of the target task, 2-1 represents the target task type, and 2 in 2-1 represents the usage scenario for a wearable device, and 1 represents the task type for a page drawing task. Multiple historical resource allocation records for the target virtual machine can be shown in Table 2:

[0136] Table 2

[0137]

[0138] According to the historical task size and historical task type corresponding to each historical resource allocation record in multiple historical resource allocation records, it is determined that the second eigenvector corresponding to the historical resource allocation record of task A is [10, 1-0], where 10 represents the historical task size of task A, 1-0 represents the historical task type of task A, and 1 in 1-0 represents that the usage scenario is for vehicle-mounted equipment, and 0 represents that the task category is a video drawing task; the second eigenvector corresponding to the historical resource allocation record of task B is [2, 2-1], where 2 represents the historical task size of task B, 2-1 represents the historical task type of task B, and 2 in 2-1 represents that the usage scenario is For wearable devices, 1 indicates that the task category is a page drawing task; the second eigenvector corresponding to the historical resource allocation record of task C is [5, 3-1], where 5 indicates the historical task size of task C, 3-1 indicates the historical task type of task C, and 3 in 3-1 indicates that the usage scenario is for mobile devices, and 1 indicates that the task category is a page drawing task; the second eigenvector corresponding to the historical resource allocation record of task D is [2, 2-1], where 2 indicates the historical task size of task B, 2-1 indicates the historical task type of task B, and 2 in 2-1 indicates that the usage scenario is for wearable devices, and 1 indicates that the task category is a page drawing task.

[0139] The first eigenvector is matched with the second eigenvectors corresponding to the historical resource allocation records of Task A, Task B, Task C, and Task D, respectively. The second eigenvectors that match the first eigenvector are the second eigenvectors corresponding to the historical allocation records of Task B and Task D. Therefore, the second allocation record is determined to be the historical allocation record of Task B and Task D. The average value of the historical GPU occupancy duration in the second allocation record is calculated to be (3 + 5) / 2 = 4 microseconds, thus determining the target occupancy duration to be 4 microseconds.

[0140] exist Figure 3In the illustrated embodiment, the target occupancy duration can be determined based on the task size, target task type, first correspondence, and second correspondence of the target task; or, based on the first time difference between the execution time of the target task and the start time of the current time, and the second time difference between the historical allocation time of each historical resource allocation record and the start time of the corresponding period in multiple historical resource allocation records, a first allocation record with similar time characteristics to the target task is determined, and the target occupancy duration is determined based on the historical GPU occupancy duration in the first allocation record; or, based on the task size and target task type of the target task, at least one second allocation record matching the task size and target task type of the target task is determined from multiple historical resource allocation records, and the target occupancy duration is determined based on the historical GPU occupancy duration in the second allocation record. Through the above method, the target occupancy duration can be determined based on the task information of the target task and / or multiple historical resource allocation records in different ways, thereby improving the accuracy of determining the target occupancy duration required by the target virtual machine for the GPU, thereby improving the resource utilization of the GPU.

[0141] In the above embodiment, the resource allocation method provided by the embodiment of the present application and the method for determining the target occupancy time are introduced. Figure 4 , the resource allocation process is further explained through specific embodiments.

[0142] Figure 4 This is a signaling diagram of a resource allocation method provided in an embodiment of the present application. Figure 4 , the method may include the following steps:

[0143] S41: Determine a target task to be processed in a target virtual machine.

[0144] For a detailed description of this step, see Figure 2 S21 in the illustrated embodiment will not be described in detail here.

[0145] S42: Determine the target occupancy time required by the target virtual machine on the GPU according to the target task.

[0146] For a detailed description of this step, see Figure 3 The embodiments shown will not be described in detail here.

[0147] It should be noted that the method for determining the target virtual machine's target GPU occupancy time is as follows: Figure 3 In addition to the method described in the illustrated embodiment, it can also be implemented in other ways. This application does not limit the method for determining the target occupancy time.

[0148] S43. Generate a resource allocation request according to the target occupancy time, where the resource allocation request includes the target occupancy time.

[0149] The resource allocation request is used to request allocation of GPU resources corresponding to the target occupancy duration for the target virtual machine.

[0150] For example, assuming that the target occupancy time is 7 microseconds, a resource allocation request is generated according to the target occupancy time. The resource allocation request includes 7 microseconds and is used to request allocation of GPU resources corresponding to 7 microseconds for the target virtual machine.

[0151] S44. Determine a target transmission mode, which may be a cross-domain communication mode or a shared memory mode.

[0152] When determining the target transmission method, it's usually necessary to select an appropriate transmission method based on factors such as the specific application scenario, data transmission requirements, and performance requirements. Cross-domain communication is typically used for data transmission between different thresholds or processes. This method is suitable for scenarios requiring communication between different security thresholds, network nodes, or processes. Shared memory is suitable for communication between different processes on the same machine. This method allows multiple processes to access the same block of memory, enabling fast data exchange.

[0153] S45. Send a resource allocation request to the resource calling device through a target transmission method.

[0154] The target virtual machine sends the resource allocation request to the resource calling device in the following manner: according to the target transmission mode, the target virtual machine sends the resource allocation request to the resource calling device through the virtual machine management program.

[0155] For example, assuming that the target transmission party adopts a cross-domain communication mode, the target virtual machine sends a resource allocation request to the resource calling device through the virtual machine hypervisor according to the cross-domain communication mode.

[0156] S46: Receive a resource allocation response sent by the resource calling device, where the resource allocation response includes a target time period, and the duration of the target time period is the target occupancy duration.

[0157] The resource allocation response is a response to a resource allocation request, indicating that the target VM can access GPU resources within a target period. The target period starts when the resource calling device sends the resource allocation response, and ends when the target period has elapsed since the start time, equal to the target occupancy duration.

[0158] After receiving the resource allocation request sent by the target virtual machine, the resource calling device monitors the status of the GPU. If the GPU is in an idle state, it sends a resource allocation response to the target virtual machine, indicating that the target virtual machine can access the GPU resources starting from the start time of the target period and within the target occupancy time.

[0159] S47. Invoke the GPU to execute the target task within the target period.

[0160] After receiving the resource allocation response, the target virtual machine accesses the GPU resources and uses the GPU resources to execute the target task within the target time period.

[0161] For example, assuming the target period is a period starting at time X and lasting 5 microseconds, after receiving the resource allocation response, the target virtual machine accesses the GPU resources within the target period and uses the GPU resources to execute the target task.

[0162] exist Figure 4 In the illustrated embodiment, the target task to be processed in the target virtual machine is first determined, and the target occupancy time required by the target virtual machine for the GPU is determined based on the target task. Then, a resource allocation request is generated based on the target occupancy time, and the target transmission mode is determined based on factors such as the specific application scenario and data transmission requirements. Then, based on the target transmission mode, a resource allocation request is sent to the resource calling device through the virtual machine hypervisor. Finally, a resource allocation response is received from the resource calling device, and the GPU resources are accessed and the target task is executed within the target time period. In the above method, the target occupancy time is determined based on the target task, and when the GPU is idle, the GPU resources are accessed within the target time period with the target occupancy time as the duration, and the GPU resources are used to execute the target task, thereby improving the resource utilization of the GPU.

[0163] Figure 5 This is a schematic diagram of the structure of a resource allocation device provided in an embodiment of the present application. Figure 5 As shown, the resource allocation device 50 includes a determination module 51, a processing module 52 and a sending module 53, wherein:

[0164] A determination module 51 is configured to determine a target task to be processed by a target virtual machine, where the target virtual machine shares resources of a graphics processor (GPU) with at least one other virtual machine;

[0165] A processing module 52 is configured to determine a target occupancy time required by a target virtual machine on a GPU according to a target task;

[0166] The sending module 53 is used to send a resource allocation request to the resource calling device corresponding to the GPU according to the target occupancy time. The resource allocation request is used to request allocation of GPU resources corresponding to the target occupancy time for the target virtual machine.

[0167] In a possible implementation, the processing module 52 is specifically configured to:

[0168] Get the task information of the target task, including the task size and target task type;

[0169] Obtain multiple historical resource allocation records of the target virtual machine, including historical task size, historical task type, historical GPU occupancy time, and historical allocation time;

[0170] Determine the target occupancy time based on task information and / or multiple historical resource allocation records.

[0171] In a possible implementation, the processing module 52 is specifically configured to:

[0172] Determining a first occupied duration according to the task size and a first corresponding relationship, wherein the first corresponding relationship includes a plurality of task size intervals and an occupied duration corresponding to each task size interval;

[0173] Determining a target weight coefficient according to the target task type and a second corresponding relationship, wherein the second corresponding relationship includes multiple task types and weight coefficients corresponding to each task type;

[0174] The product of the first occupation time and the target weight coefficient is determined as the target occupation time.

[0175] In a possible implementation, the processing module 52 is specifically configured to:

[0176] Determine the execution time of the target task;

[0177] determining a first time difference between the execution time and the start time of the current cycle;

[0178] For any historical resource allocation record, determining a second time difference between a historical allocation time in the historical resource allocation record and a start time of a corresponding period;

[0179] Determining, based on the first time difference and the second time difference corresponding to each historical resource allocation record, at least one first allocation record from the plurality of historical resource allocation records, wherein a difference between the second time difference corresponding to the first allocation record and the first time difference is less than or equal to a preset threshold;

[0180] A target GPU occupancy duration is determined according to a historical GPU occupancy duration in the at least one first allocation record.

[0181] In a possible implementation, the processing module 52 is specifically configured to:

[0182] Determine a first eigenvector corresponding to the task information;

[0183] For any historical resource allocation record, generate a second feature vector corresponding to the historical resource allocation record according to the historical task size and historical task type in the historical resource allocation record;

[0184] determining at least one second allocation record from a plurality of historical resource allocation records according to the first eigenvector and the second eigenvector;

[0185] The target GPU occupancy duration is determined according to the historical GPU occupancy duration in the at least one second allocation record.

[0186] In a possible implementation, the sending module 53 is specifically configured to:

[0187] Generate a resource allocation request according to the target occupancy time, where the resource allocation request includes the target occupancy time;

[0188] Determine the target transmission mode, which can be cross-domain communication or shared memory;

[0189] Send a resource allocation request to the resource calling device through the target transmission mode.

[0190] In one possible implementation, the device further includes:

[0191] Receive a resource allocation response sent by the resource calling device, where the resource allocation response includes a target time period, and the duration of the target time period is the target occupancy time period;

[0192] During the target period, the GPU is called to execute the target task.

[0193] The resource allocation device provided in the embodiment of the present application can implement the technical solution of the resource allocation method in the above method embodiment. Its implementation principles and beneficial effects are similar and will not be repeated here.

[0194] Figure 6 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present application. The electronic device 60 includes:

[0195] at least one processor 62; and

[0196] A memory 61 in communication with at least one processor 62; wherein,

[0197] The memory 61 stores instructions that can be executed by at least one processor 62. The instructions are executed by the at least one processor 62 to enable the at least one processor 62 to perform the resource allocation method involved in the above method embodiment.

[0198] Optionally, the processor may be a central processing unit (CPU), a GPU, other general-purpose processors, a digital signal processor (DSP), or an application-specific integrated circuit (ASIC). A general-purpose processor may be a microprocessor or any conventional processor. The steps of the method disclosed in the embodiments of the present application may be directly implemented as being executed by a hardware processor, or may be implemented by a combination of hardware and software modules in the processor.

[0199] The electronic device 60 provided in the embodiment of the present application can execute the resource allocation method involved in the above method embodiment. Its implementation principles and beneficial effects are similar and will not be repeated here.

[0200] An embodiment of the present application provides a non-transitory computer-readable storage medium, wherein the computer-readable storage medium stores computer-executable instructions, and the computer-executable instructions are used to enable a computer to execute the resource allocation method involved in the above method embodiment.

[0201] An embodiment of the present application provides a computer program product, including a computer program, which, when executed by an electronic device, implements the resource allocation method involved in the above method embodiment.

[0202] An embodiment of the present application provides a chip, which includes at least one processor, and the processor is used to run program instructions to execute the resource allocation method in the above method embodiment.

[0203] An embodiment of the present application provides a chip module having a computer program stored thereon. When the computer program is executed by the chip module, the resource allocation method in the above method embodiment is implemented.

[0204] All or part of the steps of the above-mentioned method embodiments can be completed by hardware related to program instructions. The aforementioned program can be stored in a readable memory. When the program is executed, it performs the steps of the above-mentioned method embodiments; and the aforementioned memory (storage medium) includes: read-only memory (ROM), RAM, flash memory, hard disk, solid-state drive, magnetic tape, floppy disk, optical disc, and any combination thereof.

[0205] The embodiments of the present application are described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the embodiments of the present application. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of the processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processing unit of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable terminal device to generate a machine, so that the instructions executed by the processing unit of the computer or other programmable terminal device generate instructions for implementing the steps in the process. Figure 1 a process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0206] These computer program instructions may also be stored in a computer readable memory that can direct a computer or other programmable terminal device to operate in a specific manner, so that the instructions stored in the computer readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1 a process or multiple processes and / or boxes Figure 1 The function specified in one or more boxes.

[0207] These computer program instructions can also be loaded onto a computer or other programmable terminal device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing instructions for executing on the computer or other programmable device to implement the process. Figure 1 a process or multiple processes and / or boxes Figure 1 A step that specifies a function in one or more boxes.

[0208] Obviously, those skilled in the art may make various changes and modifications to the embodiments of the present application without departing from the spirit and scope of the present application. Thus, if these modifications and variations of the embodiments of the present application fall within the scope of the claims of the present application and their equivalents, the present application is intended to include such modifications and variations.

[0209] Those skilled in the art will appreciate that all or part of the steps in the above-described method embodiments can be implemented using hardware associated with program instructions. The aforementioned program can be stored in a computer-readable storage medium. When executed, the program performs the steps in the above-described method embodiments. The aforementioned storage medium includes various media capable of storing program code, such as ROM, RAM, magnetic disks, or optical disks.

[0210] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some or all of the technical features therein. These modifications or replacements do not deviate the essence of the corresponding technical solutions from the scope of the technical solutions of the embodiments of the present application.

Claims

1. A resource allocation method, characterized in that: include: Determine a target task to be processed by a target virtual machine, where the target virtual machine shares resources of a graphics processor GPU with at least one other virtual machine; Determine, according to the target task, a target occupancy time required by the target virtual machine for the GPU; According to the target occupancy time, a resource allocation request is sent to a resource calling device corresponding to the GPU, wherein the resource allocation request is used to request allocation of GPU resources corresponding to the target occupancy time for the target virtual machine.

2. The method according to claim 1, characterized in that Determining, according to the target task, a target occupancy time required by the target virtual machine for the GPU, including: Acquire task information of the target task, wherein the task information includes task size and target task type; Acquire multiple historical resource allocation records of the target virtual machine, wherein the historical resource allocation records include historical task size, historical task type, historical GPU occupancy time, and historical allocation time; The target occupancy duration is determined according to the task information and / or the plurality of historical resource allocation records.

3. The method according to claim 2, characterized in that Determining the target occupied time according to the task information includes: Determining a first occupied time according to the task size and a first corresponding relationship, wherein the first corresponding relationship includes a plurality of task size intervals and an occupied time corresponding to each task size interval; Determining a target weight coefficient according to the target task type and a second corresponding relationship, wherein the second corresponding relationship includes a plurality of task types and a weight coefficient corresponding to each task type; The target occupation time is determined as the product of the first occupation time and the target weight coefficient.

4. The method according to claim 2, characterized in that: Determining the target occupancy duration according to the plurality of historical resource allocation records includes: Determining the execution time of the target task; Determining a first time difference between the execution time and the start time of the current cycle; For any historical resource allocation record, determining a second time difference between a historical allocation time in the historical resource allocation record and a start time of a corresponding period; Determine at least one first allocation record from the plurality of historical resource allocation records according to the first time difference and the second time difference corresponding to each historical resource allocation record, wherein the difference between the second time difference corresponding to the first allocation record and the first time difference is less than or equal to a preset threshold; The target occupancy duration is determined according to the historical GPU occupancy duration in the at least one first allocation record.

5. The method according to claim 2, characterized in that: Determining the target occupancy time according to the task information and the plurality of historical resource allocation records includes: Determining a first feature vector corresponding to the task information; For any historical resource allocation record, generating a second feature vector corresponding to the historical resource allocation record according to the historical task size and the historical task type in the historical resource allocation record; Determine at least one second allocation record in the plurality of historical resource allocation records according to the first feature vector and the second feature vector; The target occupancy time is determined according to the historical GPU occupancy time in the at least one second allocation record.

6. The method according to any one of claims 1 to 5, characterized in that: Sending a resource allocation request to a resource calling device corresponding to the GPU according to the target occupancy time includes: generating the resource allocation request according to the target occupation time, wherein the resource allocation request includes the target occupation time; Determine a target transmission mode, where the transmission mode is a cross-domain communication mode or a shared memory mode; The resource allocation request is sent to the resource calling device through the target transmission mode.

7. The method according to any one of claims 1 to 6, characterized in that: The method further comprises: Receiving a resource allocation response sent by the resource calling device, wherein the resource allocation response includes a target time period, and the duration of the target time period is the target occupancy duration; In the target time period, the GPU is called to execute the target task.

8. A resource allocation device, characterized in that: include: A determination module, used for determining a target task to be processed by a target virtual machine, wherein the target virtual machine shares resources of a graphics processor GPU with at least one other virtual machine; A processing module, configured to determine a target occupancy time required by the target virtual machine for the GPU according to the target task; The sending module is used to send a resource allocation request to a resource calling device corresponding to the GPU according to the target occupancy time, wherein the resource allocation request is used to request allocation of GPU resources corresponding to the target occupancy time for the target virtual machine.

9. An electronic device, characterized in that: include: at least one processor; as well as a memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to perform the resource allocation method according to any one of claims 1 to 7.

10. A non-transitory computer-readable storage medium, characterized in that in, The computer-readable storage medium stores computer-executable instructions, and the computer-executable instructions are used to enable a computer to execute the resource allocation method according to any one of claims 1 to 7.

11. A computer program product, comprising a computer program, characterized in that When the computer program is executed by a processor, the resource allocation method according to any one of claims 1 to 7 is implemented. 12 . A chip comprising at least one processor, wherein the processor is configured to run program instructions to execute the resource allocation method according to claim 1 .

Images