CN116360929A

CN116360929A - Multi-rendering task scheduling method for service quality perception of interactive application

Info

Publication number: CN116360929A
Application number: CN202111625247.9A
Authority: CN
Inventors: 谢瑞桃; 方俊鸿; 姚俊梅; 伍楷舜
Original assignee: Shenzhen University
Current assignee: Shenzhen University
Priority date: 2021-12-28
Filing date: 2021-12-28
Publication date: 2023-06-30

Abstract

The invention discloses a service quality perception multi-rendering task scheduling method aiming at interactive application. The method comprises the following steps: modeling the multi-rendering task as a task scheduling problem for selecting the task to be rendered and the resolution used by the task to meet the quality of service requirements and maximize the minimum utility among all the tasks; the task scheduling problem is solved through multiple rounds of interaction between a resolution adjustment algorithm and a frame rate fair scheduling algorithm, wherein the resolution adjustment algorithm is used for selecting resolution for tasks, the frame rate fair scheduling algorithm is used for deciding tasks to be processed, and constraint conditions for solving the task scheduling problem comprise various performances such as resolution, frame rate and delay. The invention fully balances the conflict between the performances, so that the various performances can meet the requirements as much as possible, and the probability of meeting all the service qualities is obviously improved.

Description

Multi-rendering task scheduling method for service quality perception of interactive application

Technical Field

The invention relates to the technical field of cloud computing, in particular to a service quality perception multi-rendering task scheduling method for interactive application.

Background

With emerging edge computing and 5G networks, the 3D rendering tasks of interactive applications (e.g., virtual reality and cloud games) can be offloaded onto edge servers. In order to improve resource utilization, multiple rendering tasks run on the same GPU server and compete with each other for computing resources. Each task has a corresponding performance requirement, i.e. quality of service requirement. Given a set of rendering tasks running on a server and sharing GPU resources and a set of available resolutions, knowing the quality of service requirements of each rendering task, when the server computing resources are idle, the scheduler needs to perform two decisions: 1) Which task is scheduled; 2) Which resolution is used for rendering. The optimization objective of the scheduler is: on one hand, the service quality requirements of all tasks are met; on the other hand, the scheduler needs to make full use of resources, optimizing the performance of all tasks to maximize user satisfaction. For example, regarding the quality of service and performance of rendering tasks, consideration needs to be given to performance affecting the interactive application user experience, such as resolution, frame rate, and latency.

Edge computation occurs in the form of localized clouds. Since the edge server is close to the user, the response time of the user request can be reduced. Cloud-based interactive applications, such as virtual reality and cloud gaming, utilize cloud resources to handle computationally intensive tasks, thereby avoiding the need for high-end hardware (often expensive and high-energy) by user equipment, and making clients lightweight. However, cloud-based interactive applications require high throughput and low latency network connections. If the distance between the user and the data center is large, the user's low latency requirements will be difficult to meet. One solution to overcome this problem is to use emerging mobile edge calculations. Specifically, the edge-assisted interactive application offloads the computationally intensive 3D rendering tasks into the mobile edge computing system and streams the edge-rendered video to the end user over a 5G connection. This approach can significantly reduce latency as the edge server is close to the end user.

As shown in fig. 1, an edge-assisted interactive application consists of three parts distributed in different locations: application logic running in the cloud server, a rendering engine running in the edge server, and display and control components running in the user device. These three parts interact with each other. Specifically, the rendering engine receives rendering instructions from the application logic, executes the instructions, and transmits rendering frames to the user device. The user device generates control instructions and transmits the control instructions back to the cloud server, which updates the application logic after receiving the control instructions. The application logic may also be offloaded to the edge server, in which case the rendering task scheduling problem is also the same.

For a rendering task, once its resource requirements and quality of service are set, the provider assigns it to an edge server. In order to improve the resource utilization rate, a plurality of rendering tasks simultaneously run on one edge server and share the same processor, and each rendering task provides rendering service for one interactive application program. The rendering tasks compete with each other for computing resources. The execution of each task is scheduled by a scheduler to achieve a preset quality of service. Therefore, the technical problems to be solved are: how to schedule rendering tasks so that all tasks can get good performance while meeting quality of service requirements.

In the prior art, the rendering task scheduling scheme mainly has the following defects: 1) The scheduling method of the shared GPU is applicable to general application programs and is not aimed at the interactive application, so that the methods only consider the resource utilization rate, but not consider the performance of the interactive application; 2) The existing method only decides to schedule tasks, but does not relate to resolution decision; 3) For edge-assisted or cloud-assisted interactive applications, existing methods improve user experience quality or reduce latency in terms of rendering mechanisms, rendering instruction compression, and compression parameter selection, but do not optimize performance through scheduling of multiple rendering tasks.

For example, one simple method of scheduling multiple rendering tasks is to schedule multiple rendering tasks in a round-robin fashion and using a fixed resolution. Since the tasks are all performed at the same frequency, this results in a fixed frame rate for all tasks. First, different tasks may have different frame rate requirements, so the frame rate requirements of certain tasks are not met. Second, this approach does not fully utilize computing resources. Therefore, this approach does not achieve the goal of optimizing both the decision-making task and the resolution used. Furthermore, increasing resolution increases both processing time and transmission time, and excessively increasing resolution may violate delay requirements. Therefore, the scheduling algorithm must consider the trade-off between each pair of performances and try to make the optimal choice.

Disclosure of Invention

The invention aims to overcome the defects of the prior art, and provides a scheduling method of a plurality of rendering tasks aiming at the edge-assisted or cloud-assisted interactive application.

The technical scheme of the invention is to provide a multi-rendering task scheduling method aiming at service quality perception of interactive application. The method comprises the following steps:

modeling a multi-rendering task as a task scheduling problem for selecting the task to be rendered and the resolution it uses to meet quality of service requirements and maximize the minimum utility among all tasks, expressed as:

wherein, the liquid crystal display device comprises a liquid crystal display device,

is a set utility function, +.>

And->

Respectively represent tasks s _i Required resolution, maximum tolerable frame interval and maximum tolerable delay, m _i Representing tasks s _i The number of instructions executed in r _ij Indicating a resolution, h, selected for execution of the j-th instruction _ij And d _ij Representing a frame interval and delay resulting from the instruction being executed;

the task scheduling problem is solved by multiple rounds of interactions between a resolution adjustment algorithm for selecting a resolution for the task and a frame rate fair scheduling algorithm for deciding the task to be processed.

Compared with the prior art, the invention has the advantages that the performance of the interactive application is considered, so that the task scheduling and the resolution selection are decided; the method can remarkably improve the resolution and the frame rate of the task and improve the performance of the task under the conditions of low load and abundant computing resources; the minimum frame rate requirement is considered, and the probability of meeting the minimum frame rate requirement is improved through reasonable modeling and method design; by designing the utility function, conflicts between performances are fully weighed, so that various performances can meet requirements as much as possible, and the probability of meeting all service quality is improved.

Other features of the present invention and its advantages will become apparent from the following detailed description of exemplary embodiments of the invention, which proceeds with reference to the accompanying drawings.

Drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments of the invention and together with the description, serve to explain the principles of the invention.

FIG. 1 is a system architecture diagram of edge 3D rendering according to one embodiment of the invention;

FIG. 2 is a schematic diagram of a solution of a scheduling sequence using a heuristic algorithm in accordance with one embodiment of the present invention;

FIG. 3 is a schematic diagram of an empirical cumulative distribution function of processing time samples rendered using various resolutions according to one embodiment of the invention;

FIG. 4 is a histogram of delay constraints according to one embodiment of the invention;

FIG. 5 is a graph of the minimum utility value containing penalty terms at various computational loads, where FIG. 5 (a) corresponds to low load and FIG. 5 (b) corresponds to high load, according to one embodiment of the invention;

FIG. 6 is a graph of minimum utility values without penalty terms under various computational loads, where FIG. 6 (a) corresponds to low load and FIG. 6 (b) corresponds to high load, according to one embodiment of the invention;

FIG. 7 is a schematic diagram of a penalty for frame interval variation under various computational loads, according to one embodiment of the invention;

FIG. 8 is a schematic diagram of percentages of an example of meeting quality of service under various computational loads, according to one embodiment of the invention;

FIG. 9 is a graph of minimum utility values containing penalty terms under various computational loads, where FIG. 9 (a) corresponds to low load and FIG. 9 (b) corresponds to high load, when each method is combined with a resolution adjustment algorithm, according to one embodiment of the present invention;

FIG. 10 is a graph illustrating the utility gain resulting from each method in combination with a resolution adjustment algorithm, according to one embodiment of the invention;

fig. 11 is a schematic diagram of percentages of examples of meeting quality of service with and without a resolution adjustment algorithm according to one embodiment of the invention.

Detailed Description

Various exemplary embodiments of the present invention will now be described in detail with reference to the accompanying drawings. It should be noted that: the relative arrangement of the components and steps, numerical expressions and numerical values set forth in these embodiments do not limit the scope of the present invention unless it is specifically stated otherwise.

The following description of at least one exemplary embodiment is merely exemplary in nature and is in no way intended to limit the invention, its application, or uses.

Techniques, methods, and apparatus known to one of ordinary skill in the relevant art may not be discussed in detail, but are intended to be part of the specification where appropriate.

In all examples shown and discussed herein, any specific values should be construed as merely illustrative, and not a limitation. Thus, other examples of exemplary embodiments may have different values.

It should be noted that: like reference numerals and letters denote like items in the following figures, and thus once an item is defined in one figure, no further discussion thereof is necessary in subsequent figures.

The invention provides a service quality aware multi-rendering task scheduling method. The method decides in real time which resolution is used to perform which task, so that the quality of service requirements of the user are met while maximizing the performance of the user. The invention models the multitask scheduling problem as a maximum and minimum utility problem with limited service quality, and provides a high-efficiency scheduling method for solving the problem. The provided scheduling method consists of a resolution adjustment algorithm and a frame rate fair scheduling algorithm, wherein the resolution adjustment algorithm intelligently selects the resolution for the tasks, and the frame rate fair scheduling algorithm decides which task to process.

For clarity, the quality of service will be specifically described hereinafter, respectively; modeling task scheduling, including maximum and minimum utility problems with limited service quality, utility functions and punishments for frame interval variation; the overall scheduling method comprises a resolution adjustment method and a frame rate fair scheduling method; a resolution adjustment method; the frame rate fair scheduling method needs to solve two sub-problems, namely a weighted maximum and minimum frame rate problem and a scheduling sequence problem; weighting maximum and minimum frame rate problems and solving methods; scheduling sequence problems and solving methods.

1. Quality of service

In the following description, three properties of the interactive application are considered in combination: resolution, frame rate, and delay are illustrated as examples. Resolution and frame rate are two key issues for video applications. High resolution may lead to better image quality, while high frame rates may lead to smooth user interaction. Delay is critical to the user experience of the interactive application. The low latency may ensure a response to user interaction. Only the delay associated with the rendering schedule, i.e. the delay from the arrival of a rendering instruction at the system to the receipt of the corresponding rendering frame by the user, is considered below. There is a trade-off between resolution and delay. High resolution can extend rendering time and transmission time, thereby increasing latency. There is also a trade-off between resolution and frame rate. High resolution reduces the scheduling frequency and thus the frame rate. The quality of service objective referred to in the present invention refers to the minimum requirements for these three properties.

2. Modeling of task scheduling problems

For a task, a utility function may be employed to quantify its performance. Since there are multiple tasks that need to be optimized, the maximization of the minimum utility is illustrated as an example, and the maximum and minimum modeling is abbreviated. The rationale for this maximum-minimum modeling is to try best to meet all users' requirements and provide additional performance (e.g., better frame quality) when computing resources are adequate. Given n tasks on a server, once the server is idle, each task either has one instruction or no instruction, and the task scheduling problem is to select one instruction to render (corresponding to a certain task) and one resolution to use so that all quality of service (resolution, frame rate and latency) requirements are met and the minimum utility among all tasks is maximized. This is a quality of service limited maximum and minimum utility problem.

1) Maximum and minimum utility problem with limited quality of service

For a task, given its required resolution r _min And the resolution r obtained by it, its performance is modeled as

Where u (x) is a concave non-decreasing utility function. If x is greater than 1, u (x) is positive, otherwise negative. Similarly, for maximum tolerable delay d _max Its performance was modeled as +.>

However, for the minimum required frame rate f _min Using its inverse, i.e. frame interval +.>

To measure performance. The frame interval is the time elapsed between two consecutive frames and the frame rate is the statistical data over a period of time. The frame interval has a more stringent constraint because a constant frame interval can ensure that frames received by a user are evenly distributed over time, while a constant frame rate cannot. Thus, for frame rate requirements, its performance is modeled as

Where h is the measured frame interval. In one embodiment, the overall performance is defined as a weighted sum, expressed as:

wherein θ _r 、θ _h And theta _d Weights for balancing each performance. They are all non-negative and the sum is 1.

Given n tasks, use { s } ₁ ,s ₂ …s _n And } represents. Each task receives a series of instructions, some of which are executed and some of which are discarded. For those instructions that are executed, the rendered frames that they generate will be encoded and transmitted over the network. However, both phases may be congested and may lead to frame loss. Thus, frames received by the client are taken to evaluate performance. Let m _i Representing tasks s _i The rendered frames of these instructions are successfully received by the corresponding user. To execute the j-th instruction, one is selected Resolution r _ij After the instruction is executed, the frame interval h can be obtained _ij And delay d _ij . The instantaneous utility, u (r), can be obtained by equation (1) _ij ,h _ij ,d _ij ). In one embodiment, the utility of a task is defined as the average utility of all of its executed instructions, u _i The expression is that:

however, the utility function does not take into account fluctuations in frame spacing, which may negatively impact the user experience. In view of this, in another embodiment, a penalty term v is added to the utility function _i And defines the final utility as follows:

where phi is the weight parameter. It should be noted that u _i And

can be used as utility function, unless otherwise indicated, in the following description, default is +.>

An example is described.

Specifically, the multi-rendering task scheduling problem is modeled as:

wherein the method comprises the steps of

And->

Respectively represent tasks s _i The required resolution, the maximum tolerable frame interval and the maximum tolerable delay. Three constraints in the modeling described above ensure average performance for each type. For the modeled problem and a scheduling policy, if all three constraints are satisfied, it is said that the quality of service is satisfied; otherwise, it is called a violation of quality of service.

2) Definition of the Utility function u (x)

To effectively constrain the above three average performances, in one embodiment, a utility function is defined, generally expressed as:

where α is a non-negative constant, used to adjust the penalty. When x >1, u (x) is within (0, 1), when x=1, u (x) =0, and when x <1, u (x) is within [ - ≡ - α).

The advantages of this utility function over conventional log (x) are mainly represented by: first, the upper limit is 1, rather than increasing to infinity. This helps balance the trade-off between the three properties. Second, the utility function has two segments, where the parameters of the negative segment can be adjusted so that any performance violation can be penalized enough to avoid problems with natural logarithms as utility functions, since one performance is over-lifted while the other performance is reduced. In other words, by setting the parameter α, u (r, h, d) <0 can be made to hold when any type of performance is violated.

Preferably three functions

And->

Respectively set alpha and respectively use alpha _r 、α _h And alpha _d And (3) representing. The specific arrangement is as follows:

α _r ＝σ(θ _r ),α _h ＝σ(θ _h ),andα _d ＝σ(θ _d ) (6)

wherein:

3) Penalty for frame interval variation

The variation of the frame interval also has a significant impact on the user experience. For a series of frames received by the user, the smaller the frame interval fluctuation, the better the user experience. A sudden increase in frame interval may interrupt user interaction. For example, the relative standard deviation may be used to model the variation in frame spacing. The relative standard deviation is the ratio of standard deviation to mean.

For task s _i Assuming that the user receives a series of frames, the number m _i . Let h _ij Representing the frame interval at the instant after the user receives the j-th frame. Then task s _i Average value of frame interval of (2)

Average value of square of frame interval is

Let v _i Representing tasks s _i The relative standard deviation of the frame interval of (a) is:

3. task scheduling algorithm

In one embodiment, an algorithm is presented to solve the multi-task scheduling problem, consisting of a resolution adjustment algorithm and a frame rate fair scheduling algorithm. The resolution adjustment algorithm intelligently selects the resolution for the task, while the frame rate fair scheduling algorithm decides which task to process. The two interact with each other. Once the server is idle, the frame rate fair scheduler selects a task and executes its instructions using the resolution determined by the resolution adjustment algorithm. After multiple rounds of scheduling, the utility is evaluated and fed back to the resolution adjustment algorithm, which then decides how to update the resolution schedule.

4. Resolution adjustment algorithm

For each task, a total of k resolutions may be used. Low resolution may not meet resolution requirements, while high resolution may extend processing time and transmission time, resulting in increased latency and potentially violating latency constraints. Thus, when there is only one task, its utility is a concave function of resolution. However, when there are multiple tasks competing with each other, it is very complex how the resolution decisions of the tasks individually affect the final utility (minimum among all tasks).

Given n tasks and k resolutions, each task selects one resolution, n can be obtained ^k Permutation combinations, each combination representing a resolution arrangement. One simple approach is to try and select the best one from them, however, this approach requires O (n ^k ) And (3) a wheel. Furthermore, attempting too many poor arrangements can reduce overall performance. To address these issues, in one embodiment, starting from an initial arrangement, the resolution is gradually increased until the overall utility is no longer increased, thereby avoiding bad security as much as possibleAnd (5) arranging.

There are three important design issues with such an algorithm. First, the initial resolution; how to improve a resolution arrangement; thirdly, a convergence condition. These three design issues are discussed in detail below. First, the initial resolution of each task should be the resolution required by the user, so that the resolution requirement can be satisfied. Increasing the resolution of certain tasks may increase overall performance when computing resources are adequate. Among all tasks, the task with the lowest utility should be prioritized because it limits overall performance. Thus, a resolution arrangement is improved by increasing the resolution of the worst performing task by one level. By increasing the resolution until the overall utility is reduced due to insufficient computing resources, the algorithm can be considered to converge. However, randomness in the running system may lead to performance fluctuations, leading to premature convergence of the misleading algorithm. To tolerate such uncertainty, convergence is triggered only if the utility is allowed to significantly decrease. It should be noted that attempts should continue when there is no change in utility, as there may be multiple tasks where utility is minimal at the same time, in which case increasing a single resolution may not increase the minimum performance, while increasing all resolutions may.

Another key issue is when to adjust resolution. In order to evaluate the performance of a resolution arrangement as accurately as possible, it is necessary to keep a resolution arrangement long enough before it is changed. Furthermore, video coding complicates the problem. Rendered frames are typically encoded in groups of pictures (GOP). Each group of pictures includes an independently encoded intra-coded frame and a number of inter-coded frames that are encoded from previous frames in the same group of pictures. The same resolution should be used for a group of pictures, otherwise, common video coding techniques (e.g., h.264, MPEG-4, etc.) cannot be supported. Thus, for each task, the resolution can be adjusted only when one group of pictures is complete. Considering the above two aspects together, in one embodiment, the following two conditions are satisfied at the same time when a resolution adjustment is initiated: 1) The last adjustment has elapsed a sufficient time; 2) The task to be adjusted completes the encoding of one group of pictures. In the next simulation experiment, the length of the group of pictures is 64 frames, and the holding time of one resolution arrangement is set to be the time for which all tasks render 1024 frames in total.

Specifically, the resolution adjustment algorithm includes the steps of:

step S11, let vector r represent the current resolution schedule set, each element of which represents the resolution of a task, initialized to the initial schedule r _min (resolution required by the user). Let r ^* Represents the best resolution arrangement currently found, its corresponding overall utility (in

Representation) is highest.

Step S12, if there is one task S among all the tasks _k Simultaneously satisfying the following two conditions, task s _k One-time resolution adjustment is initiated: (1) the last adjustment has elapsed a sufficient time; (2) task s _k The encoding of one group of pictures is completed.

Step S13, calculating the average utility of each task from the last adjustment of the resolution (last change r) according to formula (3)

Will->

The minimum value of (2) as the overall utility->

General Utility->

For evaluating the performance of the current resolution schedule r.

Step S14, if the algorithm has converged, arranging r according to the presently found optimal resolution ^* Tasks s _k Is adjusted to an optimal value. Returning to step S12.

Step S15, if task S of resolution adjustment is started _k Is not the lowest, and returns to step S12, so that the resolution is not increased, since this cannot increase the lowest utility.

Step S16, recording optimal performance information: if it is

Ratio->

Big, then->

Become->

Optimal resolution arrangement r ^* Becomes r.

Step S17, if the following three conditions are satisfied simultaneously, by integrating the task S _k Is increased by one level to increase r: (1)

relative to->

There is no significant drop (i.e.)>

Wherein ζ is greater than or equal to 0, the parameter ζ prevents premature convergence of the algorithm due to fluctuations in utility); (2) the average performance obtained using the current resolution schedule r may satisfy three constraints of equation (4 b-4 d); (3) task s _k There is still room for improvement in resolution. Returning to step S12.

Step S18, if the three conditions in step S17 cannot be satisfied simultaneously, the algorithm converges and r is arranged according to the optimal resolution found at present ^* Tasks s _k Is adjusted to an optimal value. Returning to step S12.

In summary, the provided resolution adjustment method can find a resolution arrangement that maximizes the overall utility among an exponential number of resolution arrangements in a short time.

5. Frame rate fair scheduling algorithm

Given n tasks { s ] ₁ ,s ₂ …s _n They may be scheduled in a round robin fashion, each task will result in a similar rendering frequency and frame rate. However, this approach does not achieve optimal fairness when tasks have different requirements for frame rate/frame interval, and some demanding tasks may violate frame interval constraints. Instead, weighted maximum-minimum fairness in frame rate angle is achieved by optimizing the scheduling frequency of each task, which is referred to as a weighted maximum-minimum frame rate problem. If the frame rate of one task cannot be increased without decreasing the frame rate of another task that already has a lower frame rate, the frame rate allocation is max-min fair.

The objective of the present invention is to achieve fairness of long-term frame rate, but the scheduling frequency of one task is only planned for the next cycle, which determines the short-term frame rate. The short-term scheduling frequency versus long-term frame rate can be derived. For task s _i Let f _i Indicating its expected scheduling frequency in the next cycle, the duration of which will be determined later. Assuming that the average frame rate achieved by the task so far (i.e. the long-term frame rate) is

Then the long-term frame rate (in x) reached by the task after the next period _i Representation) is:

where β is a constant parameter. Then the long term frame rate ratio is

The weighted maximum minimum frame rate problem is to find the weighted maximum on a feasible setThe minimum fairness vector x is then analyzed. The weighted maximum and minimum fairness is defined as: given some positive weights ∈ ->

Vector x is the weighted maximum and minimum fairness over a feasible set if and only if one component x of vector x is added _s Must be reduced by some other component x _t So that->

After the weighted maximum and minimum fairness vector x is obtained, the short-term frame rate vector f can be obtained by formula (11). To ensure if task s _i Short term frame rate f of (2) _i Is not zero, it is scheduled at least once, the duration of the next cycle is set to

Thus, task s _i The number of scheduling in the next cycle (Q _i Indicated) is:

once the number of schedules per task is obtained, the tasks can be scheduled in a round-robin fashion based on these quantities. However, this scheduling may cause a fluctuation in frame interval to be large, resulting in poor performance. In order to smooth out the variation in frame intervals, it is necessary to optimize the order of task scheduling, referred to as the scheduling sequence. Modeling it as a vector whose jth element if task s _k Then represent task s _k Will be processed in step j. For example, given three tasks s ₁ 、s ₂ Sum s ₃ Assuming that there are 1, 2 and 3 instructions to execute, respectively, for three tasks in a plan, vector (s ₁ ,s ₂ ,s ₃ ,s ₂ ,s ₃ ,s ₃ ) Sum vector(s) ₁ ,s ₃ ,s ₂ ,s ₃ ,s ₂ ,s ₃ ) Is two kindsScheduling sequences. It is assumed that the time to process an instruction is the same for each task. Then for task s ₃ There are two frame interval samples under the first scheduling sequence: 1 and 0; in the second scheduling sequence, there are two frame interval samples: 1 and 1. The second scheduling sequence is superior to the first in terms of frame interval variation. In one embodiment, the scheduling sequence problem is defined as: given a set of instructions that execute in one cycle, the scheduling sequence of these instructions is optimized so that the penalty for frame interval variation is minimized.

The weighted maximum minimum frame rate problem and the scheduling sequence problem are two core problems in scheduling. After solving these two problems, the scheduling algorithm is easy to design.

Specifically, the frame rate fair scheduling algorithm includes the steps of:

step S21, for each task S _i Order D _i Indicating its value in red, initialized to 0. The iteration next of the scheduling sequence vector is initialized to 1. The total number of instructions scheduled to be executed m in the current cycle is initialized to 0.

Step S22, when the processor is idle and there is an instruction for at least one task in the queue, the following steps S23, S24 and S25 are performed to schedule one task.

Step S23, if the iterator next is larger than m, namely, one traversal of the scheduling sequence vector is completed, a new period is started, and the following steps are executed to obtain the new scheduling sequence vector:

step S23.1, solving a weighted maximum and minimum frame rate problem to obtain a scheduling frequency vector f;

step S23.2, based on f, for each task S _i The scheduling number Q of the next period can be obtained by the formula (12) _i At its value of red D _i Middle accumulation Q _i And rounding down D _i Obtaining m _i I.e. the number of instructions that are scheduled to be executed. Total number of instructions scheduled for execution m= Σin current cycle _i m _i ；

Step S23.3, vector m (the i-th element of which is m _i ) As input, solve a scheduling sequenceThe problem is that a scheduling sequence vector S is obtained;

in step S23.4, the iteration next of the reset vector S is 0.

Step S24, traversing one element each time by iterating the next traversing vector S to obtain a corresponding task S _idx Iterating the child next self-increment 1 until task s _idx Instructions are in the queue and the value D of the deficit _idx Not less than 1, the traversal is ended.

Step S25, scheduling task S _idx The corresponding red word value D _idx Minus 1. Returning to step S22.

In summary, the frame rate fair scheduling method is used for deciding the scheduling task of the next step, and the performance of all rendering tasks can be optimized by optimizing the scheduling frequency and optimizing the scheduling sequence. The optimal scheduling frequency can solve the short-term scheduling frequency of each task in a period of time, and the weighted maximum and minimum fairness of the frame rate angle of each task is realized. The optimal scheduling sequence is capable of ordering a plurality of instructions belonging to a plurality of tasks to be executed over a period of time in order to smooth out variations in the frame interval of the tasks.

6. Weighted maximum and minimum frame rate problem modeling and algorithm

The weighted maximum and minimum frame rate problem is modeled. First, a feasible set of x is modeled. Short-term frame rate f _i Is non-negative and must not be greater than the arrival rate of the command (with lambda _i Represented by), i.e. 0.ltoreq.f _i ≤λ _i . From equation (11), it can be obtained:

the arrival rate of the instructions may be estimated by statistical analysis. The time taken to execute all instructions is Σ _i t _i f _i Wherein t is _i Is task s _i Average time to process each instruction, f _i Representing the short-term frame rate. Let the duration of one cycle be 1 second, it is possible to obtain:

∑ _i＝1…n t _i f _i ≤1 (14)

from equation (11), it can be obtained:

thus, the feasible set of x is:

it is a compact convex set. The goal is to obtain a weighted maximum and minimum fairness allocation x over the set (16), where x _i Is given by the weight of

According to the maximum minimum fairness theory, x exists and can be found by a water-filling algorithm.

To more clearly demonstrate the algorithm, the above problem is transformed into a compact form. Let y _i ＝t _i x _i The problem is then equivalent to finding a weighted maximum-minimum fair allocation y among the following feasible sets,

wherein the capacity is

Lower limit->

Upper limit->

y _i The weight of (2) is +.>

Specifically, the optimized scheduling frequency algorithm includes the steps of:

in step S31, the algorithm inputs include

f _min Lambda and t are each defined by +.>

λ _i And t _i A component vector. From these inputs the following parameters were obtained: capacity C, lower limit L _i Upper limit U _i ，y _i Weight W of (2) _i 。

Step S32, the ratio of each task (i.e., y _i ) Initialized to its corresponding lower limit L _i . Let C' denote the remaining capacity, initialize to

Let I represent a set of tasks whose ratio can be further increased, initialized to {1,2, …, n }.

Step S33, find the set I with the smallest weighted ratio (i.e., y _i /W _i By V ₁ Represented), noted as a subset of tasks

Step S34, increasing the weighted ratio of the tasks in I' until either: (1) the remaining capacity is exhausted; (2) the weighted ratio reaches a second small value in I. In case (1), the weighted ratio of tasks can reach a value of

In case (2), the weighted ratio of tasks can reach the second smallest weight in IRatio of V ₂ And (3) representing. When I' =i, V ₂ Is not present. Thus, the target weighted ratio (denoted by V) that a task can reach is the minimum of the values that can be reached in both cases.

The weighting ratio y of each task in step S35, I _i Become VW _i And upper limit U _i And a minimum value therebetween.

Step S36, updating the residual capacity C' to be

And delete from I up to its upper limit U _i Is a task of (a). Steps S33-S36 are repeated until the remaining capacity C' is not greater than 0 or the set I is empty.

Step S37, for each task, get y _i After that, x can be obtained _i ＝y _i /t _i And f is obtained according to the formula (11) _i 。

Step S38, the scheduling frequency vector f is returned.

7. Scheduling sequence problem modeling and algorithm

Modeling about scheduling sequence problems is specifically: given m instructions executed in one cycle, which belong to task s _i The instruction of (1) has m _i And one period has a duration of t= Σ _i m _i t _i Wherein t is _i Is task s _i Average time per instruction is processed. The ordering problem is in period [0, T]M instructions are arranged internally such that the penalty of frame interval variation is minimized. The targets are:

m _i nim _i ze max _{i＝1，...，n} v _i (18)

wherein v is _i Is a task s defined in formula (10) _i Is a relative standard deviation of the frame interval of (a).

In the task scheduling modeling described in the second section above, the frame interval is measured at the user side. However, in the scheduling sequence problem, execution of an instruction is planned instead of realizing it, and thus a frame interval cannot be obtained in advance. Instead, the interval between the start times planned by the two instructions is used to approximate the frame interval.

The problem is a combinatorial optimization. In one embodiment, a heuristic algorithm is presented to solve it. The main idea of the algorithm is to disperse m as evenly as possible within a period _i Instructions to smooth the variation of the frame interval. Specifically, for task s _i Attempting to arrange its m _i The start times of the instructions being such that the interval between two successive starts is close to

Let o _ij Representing tasks s _i Is the jth instruction, τ _ij Indicating its start time. Then, using τ _ij -τi _,j-1 To approximate the frame interval h _ij . For instruction o _ij At the beginning time tau of the arrangement _ij After that, the end time can be approximated as τ _ij +t _i . Thus, [ tau ] _ij ,τ _ij +t _i ]Becomes a busy interval and must be divided from interval [0, T]And deleted. Note that the section mentioned in this section is left-closed and right-open. When the instruction is arranged, interval [0, T]Become a set of ordered idle intervals. Wherein the idle intervals are separated by a series of scheduled busy intervals. By using

Representing the group of free intervals, wherein->

And->

The start time and the completion time of the kth idle interval, respectively.

Given an idle interval set E, as instruction o _ij Determining a start time τ _ij . First, ensure that from the last instruction o _i,j-1 At least a time period g has elapsed since the start _i The method comprises the following steps:

τ _ij ≥τi _,j-1 +g _i (20)

next, an attempt is made to schedule instructions in idle intervals instead of busy intervals to reduce changes to the scheduled instructions. In the following two cases, instruction o _ij Can be arranged in idle intervals

Inner: 1) When τ is _i,j-1 +g _i When included in the idle interval, instructions may be arranged in the interval and τ may be set _ij Let τ be _i,j-1 +g _i The method comprises the steps of carrying out a first treatment on the surface of the 2) When the start time of the idle interval is later than tau _i,j-1 +g _i In this case, the instruction may be arranged in this section and τ may be set _ij Set to->

Thus, expressed as:

for an instruction, there may be several free intervals available for scheduling, an optional number being O (m). An interesting issue is which one should be selected. Different choices may yield different target values (18). The target value obtained for the earliest interval is usually highest because it minimizes the variation of the current task over the frame interval. Therefore, the earliest interval can be directly selected. Alternatively, each interval may be tried and an interval that optimizes the target value may be selected, but this is time consuming. These two schemes were compared by simulation experiments and their performance was found to be very similar.

A new instruction arrangement may affect an existing arrangement. Suppose an instruction o _ij Is inserted into the idle interval

In which the busy interval is [ tau ] _ij ,τ _ij +t _i ]. If the busy interval exceedsIdle interval, i.e.)>

Then the new busy interval must overlap with other existing busy intervals and therefore some existing arrangements must be adjusted to avoid such overlap. Specifically, as shown in FIG. 2 (a), the start time is later than +. >

The interval (busy interval and idle interval) offset delta, wherein:

therefore, there are:

similarly, the idle interval is shifted

The following is shown:

once an instruction is scheduled, the idle interval set E must be updated accordingly. In addition to the above-described offset, the idle interval is arranged

The process is as follows: />

As shown in fig. 2 (b), if a new busy interval [ tau ] _ij ,τ _ij +t _i ]Completely contained within the idle interval, i.e.

Then the idle interval is divided into +.>

And->

Two parts; otherwise, as shown in FIG. 2 (a), the original idle interval is truncated to +.>

Specifically, the optimized scheduling sequence algorithm includes the following steps:

in step S41, the inputs of the algorithm include m, t and τ ₀ They are each represented by m _i 、t _i And τ _i0 A component vector. τ _i0 Is task s _i The start time (relative to the current time) of the last instruction executed (instruction preceding the first instruction of the plan) is a negative value. From these inputs, one period of duration t= Σcan be obtained _i m _i t _i Adding intervals [0, T ] into the idle interval set E]Each task s is calculated by equation (19) _i Target average frame interval g of (2) _i 。

Step S42, according to the instruction number of the task (i.e. m _i ) The tasks are ordered in descending order. Each task will then be processed in turn according to this order. This is because the more instructions a task has, the more its target average frame interval g _i The lower the frame interval is, the less stable the frame interval is.

Step S43, according to the task sequence in step S42, for each task S in the sequence _i Sequentially determining m thereof _i Start time of the instruction.

Step S44, for task S _i Is not equal to the instruction o _ij Acquiring the earliest idle interval available for arranging the instruction from the idle interval set E, which is recorded as

Step S45, calculating instruction o by equation (21) _ij Start time τ of _ij . Let τ denote by τ _i j is a start time matrix. τ is updated by equation (23), i.e., the start time of the previously scheduled instruction is updated.

Step S46, the idle interval is shifted according to formula (24), and the new busy interval is removed according to formula (25), i.e. the idle interval set E is updated.

In step S47, after all instructions of all tasks are scheduled, the scheduling sequence S is obtained according to the latest τ and returned.

In order to further verify the effect of the invention, a simulation experiment is performed, and in order to make the simulation experiment more realistic, tracking data is used to generate a simulation environment. The specific arrangement is as follows.

1) Collection of tracking data

A game engine named Unity is used to render three-dimensional animated scenes at different resolutions and track processing time. Run using Nvidia GeForce GTX 1060. Higher performance GPUs are not used because Unity does not provide enough precision to track very short processing times. Instead, a medium-performance GPU is used to collect data, and then the processing time is reduced by some factor, thereby simulating rendering with a high-performance GPU. The multiple used was 0.3.

Ideally, each frame should be rendered using multiple resolutions and each rendering operation timed. However, it has been found empirically that this approach makes it difficult to obtain the exact time for each rendering operation, as Unity has many caching and threading mechanisms built in. Instead, it is empirically found that the time required to render a frame is approximately linearly related to resolution, so first rendering a scene using a selected one of the resolutions, referred to as the base resolution, and then obtaining the rendering time of the other resolution by scaling its rendering time. In the simulation experiments below, the resolution candidate set is {1920× 1080,2560 × 1440,3072 × 1728,3840 ×2160}, of which 2560×1440 is selected as the reference resolution. The scaling factors of the four resolutions were set to 0.73, 1.0, 1.37, and 2.18, respectively. The scaling factors are empirically obtained by first rendering the scene independently using different resolutions, so that the generated data is referred to as raw data, and then dividing the median of the rendering time for each resolution by the median of the reference resolution to obtain the corresponding scaling factor. Fig. 3 shows an empirical Cumulative Distribution Function (CDF) of processing time, where the generated data is shown in solid lines and the raw data is shown in dashed lines. It can be seen that for each resolution except the reference resolution (2560 x 1440), the generated data has similar statistical characteristics to the original data.

2. Quality of service requirements

A tradeoff should be considered in determining quality of service requirements. Here, a simple method is introduced. First, the trade-off between modeling resolution and delay is expressed as:

d _max ≥t _p (r _min )+t _x (r _min ) (26)

wherein t is _p (r) and t _x (r) represents the average processing time and the transmission time when the resolution r is used, respectively. Otherwise, delay limit d _max Will not be satisfied. Modeling

Where B is the number of bits per pixel, c is the compression rate, and B is the bandwidth. Second, the tradeoff between the modeling frame rate and delay is expressed as:

in such conservative estimation, parallelism of processing and transmission is omitted for simplicity.

The quality of service requirements are generated as follows. First, randomly selecting a bandwidth value B from a corresponding candidate set subject to uniform distribution, and obtaining a frame rate requirement f _min Resolution requirement r _min . These candidate sets are shown in table 1. Second, not to d _max (in milliseconds)Unit) is set to a single value, but is set to:

d _max the higher the value of (c), the greater the chance of improving resolution. Fig. 4 shows statistics of delay constraints in simulation experiments for a total of 1349 samples, with a median of 40 ms and an average of 46.3 ms. Thirdly, screening the service quality requirements satisfying the above conditions (26) and (27). The settings of parameters b and c are shown in table 1. Finally, h _max Set to 1/f _min Second.

Table 1 parameters settings of the simulation environment.

/>

In Table 1, unif { a, b } represents a discrete uniform distribution between a and b.

3. Task allocation

The task allocation is simulated to generate a group of tasks allocated on a server, called a task group. The computational load of a task is defined as the specific weight of time per second for processing. For a task, give f _min And r _min Let L denote the computational load, then there are:

L＝f _min ·t _p (r _min ) (29)

the load is in fact the minimum computational power required for a preset quality of service. Assuming that n tasks are allocated on a server, each task has a bandwidth B _i Quality of service requirements

And a load L _i Then there are two constraints on bandwidth and load：

Wherein B is _max And L _max The bandwidth limit (set to 100 megabits per second in the simulation experiment) and the load limit (set to 1 in the simulation experiment) are respectively. Other resources may be modeled in the same manner. For simplicity, an isomorphic setting is assumed, so other resource constraints can translate into a limit on the number of tasks. For example limiting the number of tasks to between 2 and 4. Because scheduling a single task is trivial, and the total load of 5 tasks is far beyond the load limit.

The task group is generated as follows. First, the possible quality of service requirements described above are generated (along with bandwidth). Second, a combination of these quality of service requirements is generated and the combination is screened for where equation (30) is satisfied. Here, each combination corresponds to one task group. Third, from these task groups, some were selected for simulation experiments based on their total load. Specifically, given a set of loads, {30%,..100% }, for each load, a task group (allowing ±1.5% fluctuation) to which the load is close is randomly selected. Here 30% is the lowest load possible.

4. Generating instructions

For a task, a series of instructions is generated, the arrival rate of which is higher than the frame rate it requires. Given a required frame rate f _min Inter-arrival compliance at

Second and->

Even distribution between seconds. The arrival of the instruction was simulated in 120 seconds. The processing time of each instruction is sequentially read from a trace data stream formed by concatenating a plurality of randomly selected data segments (5000 samples each) of original trace data generated according to the method described above. Random combinations of trace data segments allow more variations to be tested.

Furthermore, dynamic bandwidth is simulated. 3 sets of bandwidth tracking data are collected using a continuous speed test tool, one set of data for each of the candidate bandwidths (10, 20, and 30 megabits per second). For each set of data, it is first divided into 50 segments, each segment consisting of bandwidth samples lasting 120 seconds, and then an offset is added to each data segment such that its average value is equal to the specified bandwidth (10, 20, and 30 megabits per second). The instantaneous bandwidth of each frame as it is transmitted is sequentially read from the randomly selected data segments.

In addition, video coding is reduced to a short process. The encoding time of each frame is randomly chosen based on a uniform distribution of between 2 and 6 milliseconds. The length of the group of pictures is 64 frames. The compression ratio is 1:x, where x is an integer value, and x is subject to a uniform distribution over [400, 600] for intra-coded frames and over [800, 1200] for inter-coded frames. Other parameter settings of the simulation environment are as in table 1.

5) Performance assessment

The method of the invention is evaluated by simulation experiments: frame rate fair scheduling (FRF-RA for short) in combination with resolution adjustment algorithms. The settings of the relevant parameters are shown in table 2, unless otherwise specified.

The method provided by the invention is compared with the following classical scheduling method:

1) Round robin scheduling (RR): it traverses the task in a round-robin fashion.

2) First come first served schedule (FCFS): it tends to run the earliest arriving instruction preferentially.

3) Shortest remaining time first Scheduling (SRTF): it prioritizes the most urgent tasks. For a task, its urgency is evaluated using a deadline, which is the maximum tolerable frame interval of the task after the last schedule.

In the following evaluations, each value was averaged from 50 different simulation instances. Each instance uses a task allocation, a trace data segment of processing time and a trace data segment of bandwidth, which are independently randomly selected.

Table 2 parameter settings of the algorithm

6. Frame rate fair scheduling algorithm

Frame rate fair scheduling without combining resolution adjustment algorithms is first evaluated.

1) Enhancement of utility

The aim of the present invention is to minimize the utility of containing penalty terms, i.e

Fig. 5 shows the values of this effect at various computational loads, with fig. 5 (a) corresponding to low load and fig. 5 (b) corresponding to high load. It can be observed that frame rate fair scheduling (FRF) achieves the highest utility under almost all loads, while the shortest remaining time first Scheduling (SRTF) performs slightly lower than frame rate fair scheduling (FRF). The round robin scheduling (RR) and first come first served scheduling (FCFS) perform poorly, especially under high load conditions. FIG. 6 demonstrates the minimal utility of not including penalty terms, i.e., min _i＝1…n u _i Fig. 6 (a) corresponds to a low load, and fig. 6 (b) corresponds to a high load. It can be seen that frame rate fair scheduling (FRF) achieves the highest value under all loads. In addition, FIG. 7 shows the penalty for frame interval variation, i.e., max _i＝1…n v _i . It can be seen that the method (FRF) of the present invention performs almost identically to the shortest remaining time first Schedule (SRTF), which is superior to the first come first served schedule (FCFS), but worse than the round robin schedule (RR).

2) Improvement of instance ratio meeting service quality

For one problem instance, if all constraints (4 b) - (4 d) in modeling (4) are satisfied, it is said that quality of service is satisfied; otherwise, it is called a violation of quality of service. The percentage of instances of 50 simulation instances that satisfy quality of service (QoS-SAT for short) was evaluated.

It is noted that each method may satisfy the resolution constraint (4 b), but may violate other constraints. Fig. 8 shows the percentages of examples that meet the quality of service. It can be seen that the method of the present invention (FRF) gives the highest value. In contrast, all other approaches have a large number of examples that violate the quality of service. Frame rate fair scheduling (FRF) allows all instances to meet quality of service requirements even at 90% high load.

Further, from the simulation results, it was found that all methods can satisfy the delay constraint (4 d) when the delay constraint is set according to the formula (28). In this case, all instances of violating the quality of service violate the frame interval constraint (4 c).

7. Resolution adjustment algorithm

The resolution adjustment algorithm may be combined with any scheduling algorithm. The impact of the resolution adjustment algorithm on all methods was evaluated.

1) Enhancement of utility

A resolution adjustment algorithm is combined with each method and the effect on the utility is evaluated. As shown in fig. 9, the method of the present invention (FRF-RA) performs best at all loads. Fig. 10 shows the utility gain of each method compared to the original method. It can be observed that at loads below 50%, the utility of almost every method is increased. Roughly speaking, the lower the load, the higher the gain due to more free computing power.

2) Influence on the instance duty cycle to meet quality of service

Next, the impact of the resolution adjustment algorithm on meeting the quality of service is evaluated. Fig. 11 shows the percentage of examples where each method meets the quality of service with and without the resolution adjustment algorithm. It can be seen that the resolution adjustment algorithm slightly reduces the performance to meet the quality of service at high load. This drop is at the cost of increased utility at low loads, as shown in fig. 10. This is mainly due to attempts at resolution scheduling in resolution adjustment algorithms.

In summary, compared with the prior art, the invention has at least the following technical advantages:

1) Compared with the scheduling method for sharing the GPU in the prior art method, the scheduling method provided by the invention considers the performance of the interactive application, including resolution, frame rate, delay and the like, aiming at the interactive application.

2) Compared with the scheduling method for sharing the GPU in the prior art, the method provided by the invention has the advantages that the task scheduling is decided, and the resolution is also decided.

3) For edge-assisted or cloud-assisted interactive applications, the prior art improves user quality of experience or reduces latency in terms of rendering mechanisms, rendering instruction compression, and compression parameter selection, but does not optimize performance through scheduling of multiple rendering tasks. The invention realizes the performance optimization through the frame-by-frame scheduling of a plurality of rendering tasks.

4) Compared with a scheduling method based on polling and using fixed resolution, the method can fully improve the resolution and the frame rate of the task under the conditions of low load and abundant computing resources, and improves the performance of the task.

5) Compared with a scheduling method based on polling and using fixed resolution, the scheduling method considers the minimum frame rate requirement, and improves the probability of meeting the minimum frame rate requirement through reasonable modeling and method design.

6) Compared with a scheduling method based on polling and using fixed resolution, the scheduling method based on the polling and the scheduling method based on the fixed resolution fully balances conflict among performances by designing the utility function u (x) and an effective method, so that various performances (resolution, frame rate/frame interval and delay) can meet requirements as much as possible, and the probability of meeting all service qualities is improved.

The present invention may be a system, method, and/or computer program product. The computer program product may include a computer readable storage medium having computer readable program instructions embodied thereon for causing a processor to implement aspects of the present invention.

The computer readable storage medium may be a tangible device that can hold and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer-readable storage medium would include the following: portable computer disks, hard disks, random Access Memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static Random Access Memory (SRAM), portable compact disk read-only memory (CD-ROM), digital Versatile Disks (DVD), memory sticks, floppy disks, mechanical coding devices, punch cards or in-groove structures such as punch cards or grooves having instructions stored thereon, and any suitable combination of the foregoing. Computer-readable storage media, as used herein, are not to be construed as transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., optical pulses through fiber optic cables), or electrical signals transmitted through wires.

The foregoing description of embodiments of the invention has been presented for purposes of illustration and description, and is not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the various embodiments described. The terminology used herein was chosen in order to best explain the principles of the embodiments, the practical application, or the technical improvements in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein. The scope of the invention is defined by the appended claims.

Claims

1. A quality of service aware multi-rendering task scheduling method for interactive applications, comprising the steps of:

solving the task scheduling problem through multiple rounds of interaction between a resolution adjustment algorithm and a frame rate fair scheduling algorithm, wherein the resolution adjustment algorithm is used for selecting resolution for tasks, and the frame rate fair scheduling algorithm is used for deciding the tasks to be processed;

is a set utility function, +.>

And->

Respectively represent tasks s _i Required resolution, maximum tolerable frame interval and maximum tolerable delay, m _i Representing tasks s _i The number of instructions executed in r _ij Indicating a resolution, h, selected for execution of the j-th instruction _ij And d _ij Representing the frame interval and delay resulting from the instruction being executed.

2. The method of claim 1, wherein for a given task, the utility function is set to:

wherein u (r) _ij ，h _ij ，d _ij ) Is the overall performance, defined as:

r _min is the minimum resolution required, r is the resolution obtained, d _max Is the maximum tolerable delay, f _min Is the minimum frame rate required and,

h is the measured frame interval, v _i Is a punishment term for frame interval change, phi is a weight parameter, theta _r ，θ _h And theta _d Is the weight of the corresponding term.

3. The method of claim 1, wherein the resolution adjustment algorithm performs the steps of:

step S10: let vector r represent the current set of resolution schedules, where each element represents the resolution of a task, which is initialized to the resolution r required by the user _min Let r ^* Representing the best resolution arrangement currently found, its corresponding overall utility

The highest;

step S20: if there is one task s among all the tasks _k Simultaneously satisfying the following two conditions, task s _k One-time resolution adjustment is initiated: the last resolution adjustment has passed the set time threshold; task s _k The encoding of one picture group is completed;

step S30: calculate each taskAverage utility from last resolution adjustment

Will->

The minimum value of (2) as the overall utility->

For evaluating the performance of the current resolution schedule r;

step S40: if the algorithm meets the set convergence condition, r is arranged according to the best resolution found at present ^* Tasks s _k The resolution of (2) is adjusted to an optimal value;

step S50: if task s of resolution adjustment is started _k Is not the lowest utility, returning to step S20;

step S60: recording optimal performance information: if it is

Ratio->

Big, then->

Become->

Optimal resolution arrangement r ^* Becomes r;

step S70: by passing the task s if the following three conditions are satisfied simultaneously _k Is increased by one level to increase r:

wherein, xi is more than or equal to 0; average performance using current resolution schedule r satisfies task scheduling problemAll constraint conditions; task s _k Has room for improvement in resolution;

Step S80, if the three conditions cannot be satisfied at the same time, determining that the algorithm converges, and arranging r according to the currently found optimal resolution ^* Tasks s _k Is adjusted to an optimal value.

4. The method of claim 1, wherein the frame rate fair scheduling algorithm performs the steps of:

step S100, for each task S _i Order D _i The method comprises the steps of representing a red word value, initializing to 0, initializing iteration next of a scheduling sequence vector to 1, and initializing the total planned execution instruction number m in a current period to 0;

step S200, when the processor is idle and at least one task queue has instructions, the following steps S300, S400 and S500 are executed to schedule one task;

step S300, if the iteration next is larger than m, one traversal of the scheduling sequence vector is completed, a new cycle is started, and the following steps are executed to obtain a new scheduling sequence vector:

solving a weighted maximum and minimum frame rate problem to obtain a scheduling frequency vector f;

based on f, for each task s _i Calculate the scheduling times Q of the next period _i At its value of red D _i Middle accumulation Q _i And rounding down D _i Obtaining m _i The number of instructions scheduled to be executed is obtained, and the total number of instructions scheduled to be executed m= Σin the current cycle _i m _i ；

The ith element m of the vector m _i As input, solving a scheduling sequence problem to obtain a scheduling sequence vector S;

resetting the iteration next of the vector S to 0;

step S400, traversing an element each time by iterating the next traversing vector S to obtain a corresponding task S _idx Iterating the child next self-increment 1 until task s _idx Has instructions in its queue and its bare wordValue D _idx Ending the traversal with the value not smaller than 1;

step S500, scheduling task S _idx The corresponding red word value D _idx Minus 1, and returning to step S200.

5. The method of claim 4, wherein the weighted maximum and minimum frame rate problem is modeled according to the steps of:

modeling a feasible set of x, short-term frame rate f _i Is non-negative and is not greater than the arrival rate lambda of the instruction _i Expressed as 0.ltoreq.f _i ≤λ _i The following formula is satisfied:

the arrival rate of instructions is estimated by statistical analysis, and the time consumed for running all instructions is Σ _i t _i f _i Wherein t is _i Is task s _i The average time to process each instruction, let the duration of one cycle be 1 second, results in:

based on the formula

The method comprises the following steps:

thus, the feasible set of x is:

the goal of the weighted maximum minimum frame rate problem is to obtain a weighted maximum minimum fairness allocation x, where x _i Is given by the weight of

Let y _i ＝t _i x _i This problem is equivalent to finding a weighted maximum-minimum fairness allocation y among the following possible sets:

wherein the capacity is

Lower limit->

Upper limit of

y _i The weight of (2) is +.>

Beta is a constant parameter, ">

Is the average frame rate.

6. A method according to claim 5, wherein the scheduling sequence is used to optimise the order of task scheduling, the scheduling sequence problem being modelled according to the steps of:

given m instructions executed in one cycle, which belong to task s _i The instruction of (1) has m _i And one period has a duration of t= Σ _i m _i t _i Wherein t is _i Is task s _i Average time to process each instruction;

m instructions are arranged in cycles [0, t ] such that the penalty for frame interval variation is minimized, expressed as:

minimize max _{i＝1，...，n} v _i

wherein v is _i Is task s _i And approximates the frame interval using the interval between the start times planned by the two instructions.

7. The method of claim 2, wherein,

and->

The same utility function definition is used, expressed as:

and is three functions

And->

Respectively set alpha, respectively expressed as alpha _r 、α _h And alpha _d And has the following steps:

α _r ＝σ(θ _r )，α _h ＝σ(θ _h )，α _d ＝σ(θ _d )

wherein:

wherein α is a non-negative constant for adjusting penalty.

8. The method of claim 6, wherein for task s _i J-th instruction o _ij Its start time τ is arranged according to the following formula _ij ：

Wherein g _i Interval representing the start time of two consecutive instructions, interval [0, T ] when the instructions are arranged]Become an ordered set of idle intervals, and the idle intervals are separated by a series of scheduled busy intervals, using

Representing the group of free intervals +.>

And->

The start time and the completion time of the kth idle interval, respectively;

for an instruction o _ij Is inserted into the idle interval

In the internal case, the busy interval is [ τ ] _ij ，τ _ij +t _i ]If the busy interval exceeds the idle interval, i.e. +.>

The start time is later than +.>

The interval offset delta of (2) is expressed as:

9. a computer readable storage medium having stored thereon a computer program, wherein the program when executed by a processor realizes the steps of the method according to any of claims 1 to 8.

10. A computer device comprising a memory and a processor, on which memory a computer program is stored which can be run on the processor, characterized in that the processor implements the steps of the method according to any of claims 1 to 8 when the program is executed.