A dynamic computing power allocation system based on task priority

Abstract

The present invention provides a dynamic computing power allocation system based on task priority, which relates to the field of electrical digital data processing, and includes a queue management module, a progress monitoring module, a computing power adjustment module and a task execution module. The queue management module is used to receive tasks and sort and manage the tasks, the progress monitoring module is used to monitor and feedback the execution progress of the tasks, the computing power adjustment module is used to adjust and analyze the computing power allocated to the tasks, and the task execution module is used to schedule the computing power to execute the tasks. The system dynamically adjusts the computing power resources of the running tasks through the priority and other monitoring data, which can effectively improve the utilization rate of resources.

Description

Technical Field

[0001] The present invention relates to the field of electronic digital data processing, and in particular to a dynamic computing power allocation system based on task priority. Background Art

[0002] In modern high-performance computing, cloud computing, artificial intelligence and other application fields, task processing systems usually need to process multiple tasks at the same time, and different tasks have different requirements for computing resources, and the priority, real-time and resource requirements of computing tasks may change at any time. Therefore, how to reasonably allocate and dynamically adjust computing resources in an environment where multiple tasks run in parallel has become an urgent problem to be solved. Traditional task allocation methods are mostly fixed resource allocation or preset priority scheduling. Although this method can ensure the stability of task execution under static load, it often leads to resource waste or insufficient resources in a dynamic environment, and cannot meet the needs of efficient and high-quality task execution.

[0003] The foregoing discussion of the background art is intended only to facilitate an understanding of the present invention. This discussion does not acknowledge or admit that any of the material referred to is part of the common general knowledge.

[0004] Now many computing power allocation systems have been developed. After a lot of searching and reference, it is found that the existing computing power allocation system is such as the system disclosed in the publication number CN114416352B. These system methods generally include: according to the algorithm attributes of each of the multiple algorithms, the computing power requirement characteristics of each of the multiple algorithms are determined, and according to the computing power requirement characteristics of each of the multiple algorithms, the resource pool of the computing power platform is resource planned to obtain multiple sub-resource pools. Therefore, the computing power resources of the computing power platform can be planned more finely, and the planned computing power resources are more matched with the actual use environment. The software image files of each of the multiple algorithms are obtained, and deployed in the sub-resource pools that match the multiple algorithms, the algorithm application requirements of the user are obtained, and the target sub-resource pool that matches the algorithm application requirements is determined from the multiple sub-resource pools. However, the system considers the priority of the task when allocating resources, and no longer dynamically adjusts after the resources are allocated, resulting in low resource utilization of the task in the later stage of processing, which cannot meet the requirements of efficient and high-quality task execution. Summary of the invention

[0005] The purpose of the present invention is to propose a dynamic computing power allocation system based on task priority in view of the existing deficiencies.

[0006] The present invention adopts the following technical solution:

[0007] A dynamic computing power allocation system based on task priority, including a queue management module, a progress monitoring module, a computing power adjustment module and a task execution module;

[0008] The queue management module is used to receive tasks and sort and manage the tasks, the progress monitoring module is used to monitor and feedback the execution progress of the tasks, the computing power adjustment module is used to adjust and analyze the computing power allocated to the tasks, and the task execution module is used to schedule the computing power to execute the tasks;

[0009] The queue management module includes a task receiving unit, a queue-jumping processing unit and a task output unit, wherein the task receiving unit is used to receive task information, the queue-jumping processing unit is used to insert tasks into the queue, and the task output unit is used to output tasks in the queue to the task execution module;

[0010] The progress monitoring module includes a time monitoring unit, a computation amount monitoring unit and a resource utilization monitoring unit. The time monitoring unit is used to monitor the running time of each task, the computation amount monitoring unit is used to monitor the number of calculations of the task, and the resource utilization monitoring unit is used to monitor the utilization of computing power by the task;

[0011] The computing power adjustment module includes a task classification unit, a resource release adjustment unit and a resource allocation adjustment unit; the task classification unit classifies the tasks being executed based on the monitoring data, the resource release adjustment unit is used to release the computing power resources of the tasks, and the resource allocation adjustment unit is used to reallocate the released resources;

[0012] The task execution module includes a resource pairing unit, a task running unit and a feedback processing unit. The resource pairing unit pairs computing resources with tasks based on allocation information, the task running unit is used to control computing resources to execute tasks, and the feedback processing unit is used to perform feedback processing after the task is completed.

[0013] Further, the queue-jumping processing unit includes a task queue register, a queue-jumping parsing processor and a task timing processor, wherein the task queue register is used to sort the tasks and then store them, the queue-jumping parsing processor is used to obtain new tasks from the information buffer register and insert them into the task queue, and the task timing processor is used to time the time that the task exists in the queue;

[0014] The queue-jumping analysis processor calculates the task ranking index Sr according to the following formula:

[0015] ;

[0016] Among them, T is the time that the task exists in the queue, T0 is the base time, k is the conversion coefficient, and Pr is the priority;

[0017] The queue-insertion parsing processor inserts a new task into the queue based on the sorting index, so that the sorting indexes of the tasks in the queue are sorted from high to low.

[0018] Further, the resource utilization monitoring unit includes a function segmentation processor, a function calculation processor and a function update processor, the function segmentation processor performs segmentation based on the amount of resources allocated to the task, the function calculation processor is used to calculate the function value of each segment, and the function update processor is used to update the calculated function value into the monitoring target data table;

[0019] The function calculation processor calculates the utilization function value R(t) of the task in the corresponding segment according to the following formula:

[0020] ;

[0021] Among them, C(t) represents the cumulative number of calculations of the task at time point t, is the time precision of the function, V(t) is the amount of resources for the task at time point t, It is the calculation rate per unit resource amount.

[0022] Further, the resource release adjustment unit includes a release calculation processor, a release execution processor and a resource summary processor, the release calculation processor is used to calculate the amount of resources released by the task, the release execution processor is used to release the computing power resources of the task, and the resource summary processor is used to summarize the released resources and idle resources and send them to the resource allocation adjustment unit;

[0023] The release calculation processor calculates the amount of resources Rq that the task needs to release according to the following formula:

[0024] ;

[0025] Among them, Qa is the amount of resources allocated to the task, Pm is the reference priority, t0 is the starting time point of the utilization function segment, and t now Indicates the current time point.

[0026] Furthermore, the resource allocation adjustment unit includes an allocation calculation processor and an allocation output processor, the allocation calculation processor is used to calculate the amount of resources newly added to the task, and the allocation output processor is used to generate an allocation instruction and send it to the task execution module;

[0027] The allocation calculation processor calculates the relative weight h of the task according to the following formula:

[0028] ;

[0029] Among them, Qu is the resource upper limit of the task;

[0030] The allocation calculation processor calculates the newly allocated resource amount Aq(i) of the i-th task according to the following formula:

[0031] ;

[0032] Among them, h(i) represents the relative weight of the i-th task, n is the number of tasks that require additional resources, and Qz is the total amount of allocatable resources.

[0033] The beneficial effects achieved by the present invention are:

[0034] This system takes task priorities into consideration during both task queuing and resource allocation, so that urgent tasks can be processed ahead of time, improving the system's processing quality. During dynamic allocation, tasks are divided into two types: reducing resources and increasing resources, and are redistributed, so that tasks can maintain a high resource utilization rate throughout the entire processing process, thereby improving the system's efficiency.

[0035] To further understand the features and technical contents of the present invention, please refer to the following detailed description and drawings of the present invention. However, the drawings provided are only for reference and description and are not intended to limit the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0036] Figure 1 It is a schematic diagram of the overall structural framework of the present invention;

[0037] Figure 2 This is a schematic diagram of the queue management module of the present invention;

[0038] Figure 3 This is a schematic diagram of the progress monitoring module of the present invention;

[0039] Figure 4 This is a schematic diagram of the computing power adjustment module of the present invention;

[0040] Figure 5 This is a schematic diagram of the task execution module of the present invention;

[0041] Figure 6 It is the experimental test effect diagram of the present invention. DETAILED DESCRIPTION

[0042] The following is an explanation of the embodiments of the present invention through specific embodiments. Those skilled in the art can understand the advantages and effects of the present invention from the contents disclosed in this specification. The present invention can be implemented or applied through other different specific embodiments, and the details in this specification can also be modified and changed in various ways based on different viewpoints and applications without departing from the spirit of the present invention. In addition, the drawings of the present invention are only simple schematic illustrations and are not depicted according to actual sizes. It is stated in advance. The following embodiments will further explain the relevant technical contents of the present invention in detail, but the disclosed contents are not intended to limit the scope of protection of the present invention.

[0043] Embodiment 1: This embodiment provides a dynamic computing power allocation system based on task priority, combined with Figure 1 , including queue management module, progress monitoring module, computing power adjustment module and task execution module;

[0044] The queue management module is used to receive tasks and sort and manage the tasks, the progress monitoring module is used to monitor and feedback the execution progress of the tasks, the computing power adjustment module is used to adjust and analyze the computing power allocated to the tasks, and the task execution module is used to schedule the computing power to execute the tasks;

[0045] The queue management module includes a task receiving unit, a queue-jumping processing unit and a task output unit, wherein the task receiving unit is used to receive task information, the queue-jumping processing unit is used to insert tasks into the queue, and the task output unit is used to output tasks in the queue to the task execution module;

[0046] The progress monitoring module includes a time monitoring unit, a computation amount monitoring unit and a resource utilization monitoring unit. The time monitoring unit is used to monitor the running time of each task, the computation amount monitoring unit is used to monitor the number of calculations of the task, and the resource utilization monitoring unit is used to monitor the utilization of computing power by the task;

[0047] The computing power adjustment module includes a task classification unit, a resource release adjustment unit and a resource allocation adjustment unit; the task classification unit classifies the tasks being executed based on the monitoring data, the resource release adjustment unit is used to release the computing power resources of the tasks, and the resource allocation adjustment unit is used to reallocate the released resources;

[0048] The task execution module includes a resource pairing unit, a task running unit and a feedback processing unit. The resource pairing unit pairs computing resources with tasks based on allocation information, the task running unit is used to control computing resources to execute tasks, and the feedback processing unit is used to perform feedback processing after the task is completed.

[0049] The queue-jumping processing unit includes a task queue register, a queue-jumping parsing processor, and a task timing processor. The task queue register is used to sort and store tasks. The queue-jumping parsing processor is used to obtain new tasks from the information buffer register and insert them into the task queue. The task timing processor is used to time the time that the task exists in the queue.

[0050] The queue-jumping analysis processor calculates the task ranking index Sr according to the following formula:

[0051] ;

[0052] Among them, T is the time that the task exists in the queue, T0 is the base time, k is the conversion coefficient, and Pr is the priority;

[0053] The queue-insertion parsing processor inserts a new task into the queue based on the sorting index, so that the sorting indexes of the tasks in the queue are sorted from high to low.

[0054] The resource utilization monitoring unit includes a function segmentation processor, a function calculation processor and a function update processor, wherein the function segmentation processor performs segmentation based on the amount of resources allocated to the task, the function calculation processor is used to calculate the function value of each segment, and the function update processor is used to update the calculated function value into the monitoring target data table;

[0055] The function calculation processor calculates the utilization function value R(t) of the task in the corresponding segment according to the following formula:

[0056] ;

[0057] Among them, C(t) represents the cumulative number of calculations of the task at time point t, is the time precision of the function, V(t) is the amount of resources for the task at time point t, It is the calculation rate per unit resource amount.

[0058] The resource release adjustment unit includes a release calculation processor, a release execution processor and a resource aggregation processor, wherein the release calculation processor is used to calculate the amount of resources released by the task, the release execution processor is used to release the computing power resources of the task, and the resource aggregation processor is used to aggregate the released resources and idle resources and send them to the resource allocation adjustment unit;

[0059] The release calculation processor calculates the amount of resources Rq that the task needs to release according to the following formula:

[0060] ;

[0061] Among them, Qa is the amount of resources allocated to the task, Pm is the reference priority, t0 is the starting time point of the utilization function segment, and t now Indicates the current time point.

[0062] The resource allocation adjustment unit includes an allocation calculation processor and an allocation output processor, wherein the allocation calculation processor is used to calculate the amount of resources newly added to the task, and the allocation output processor is used to generate an allocation instruction and send it to the task execution module;

[0063] The allocation calculation processor calculates the relative weight h of the task according to the following formula:

[0064] ;

[0065] Among them, Qu is the resource upper limit of the task;

[0066] The allocation calculation processor calculates the newly allocated resource amount Aq(i) of the i-th task according to the following formula:

[0067] ;

[0068] Among them, h(i) represents the relative weight of the i-th task, n is the number of tasks that require additional resources, and Qz is the total amount of allocatable resources.

[0069] Embodiment 2: This embodiment provides all the contents of Embodiment 1, and provides a dynamic computing power allocation system based on task priority, including a queue management module, a progress monitoring module, a computing power adjustment module and a task execution module.

[0070] The queue management module is used to receive tasks and sort and manage the tasks, the progress monitoring module is used to monitor and provide feedback on the execution progress of the tasks, the computing power adjustment module is used to adjust and analyze the computing power allocated to the tasks, and the task execution module is used to schedule the computing power to execute the tasks.

[0071] Combination Figure 2 The queue management module includes a task receiving unit, a queue-jumping processing unit and a task output unit. The task receiving unit is used to receive task information, the queue-jumping processing unit is used to insert tasks into the queue, and the task output unit is used to output tasks in the queue to the task execution module.

[0072] Combination Figure 3 The progress monitoring module includes a time monitoring unit, a computing volume monitoring unit and a resource utilization monitoring unit. The time monitoring unit is used to monitor the running time of each task, the computing volume monitoring unit is used to monitor the number of calculations of the task, and the resource utilization monitoring unit is used to monitor the utilization of computing power by the task.

[0073] Combination Figure 4 The computing power adjustment module includes a task classification unit, a resource release adjustment unit and a resource allocation adjustment unit. The task classification unit classifies the tasks being executed based on the monitoring data, the resource release adjustment unit is used to release the computing power resources of the tasks, and the resource allocation adjustment unit is used to reallocate the released resources.

[0074] Combination Figure 5The task execution module includes a resource pairing unit, a task running unit and a feedback processing unit. The resource pairing unit pairs computing resources with tasks based on allocation information, the task running unit is used to control computing resources to execute tasks, and the feedback processing unit is used to perform feedback processing after the task is completed.

[0075] The task receiving unit includes a task identification processor, a priority assignment processor and an information buffer register. The task identification processor is used to receive and identify basic attributes of the task. The priority assignment processor assigns priorities to the tasks based on the basic attributes. The information buffer register is used to temporarily store the tasks.

[0076] The queue-jumping processing unit includes a task queue register, a queue-jumping parsing processor and a task timing processor. The task queue register is used to sort the tasks and store them. The queue-jumping parsing processor is used to obtain new tasks from the information buffer register and insert them into the task queue. The task timing processor is used to time the time the task exists in the queue.

[0077] The queue-jumping analysis processor calculates the task ranking index Sr according to the following formula:

[0078] .

[0079] Among them, T is the time that the task exists in the queue, T0 is the base time, k is the conversion coefficient, and Pr is the priority.

[0080] The larger the priority value, the higher the priority of the task.

[0081] For a new task fetched from the buffer register, the sorting index is calculated by treating T as 0.

[0082] The queue-insertion parsing processor inserts a new task into the queue based on the sorting index, so that the sorting indexes of the tasks in the queue are sorted from high to low.

[0083] The task output unit includes an output judgment processor and a data transfer processor. The output judgment processor is used to judge whether to output the first task in the queue, and the data transfer processor is used to transfer the relevant data of the first task in the queue to the task execution module.

[0084] The output determination processor receives the idle resource amount, and when the idle resource amount is greater than the minimum requirement of the first task in the queue, determines to output the task.

[0085] The time monitoring unit includes a timing start processor, a time synchronization processor and a monitoring calculation processor. The timing start processor is used to create a monitoring target data table and record the start time when running a new task. The time synchronization processor is used to provide time data synchronized with the standard time. The monitoring calculation processor is used to calculate the running time of each task at the monitoring point and report it.

[0086] The computational volume monitoring unit includes a computation counting processor, a progress calculation processor and a target update processor. The computation counting processor is used to count the cumulative number of computations of the task in real time. The progress calculation processor obtains progress data based on the number of computations. The target update processor is used to update the progress data and the number of computations to the monitoring target data table at the monitoring point.

[0087] The progress calculation processor calculates the progress value Pg of the task according to the following formula:

[0088] .

[0089] Among them, C all represents the total number of calculations required to complete the task, t now represents the current time point, C(t now ) indicates the cumulative number of calculations of the task at the current time point.

[0090] The resource utilization monitoring unit includes a function segmentation processor, a function calculation processor and a function update processor. The function segmentation processor performs segmentation based on the amount of resources allocated to the task, the function calculation processor is used to calculate the function value of each segment, and the function update processor is used to update the calculated function value into the monitoring target data table.

[0091] The function calculation processor calculates the utilization function value R(t) of the task in the corresponding segment according to the following formula:

[0092] .

[0093] Among them, C(t) represents the cumulative number of calculations of the task at time point t, is the time precision of the function, V(t) is the amount of resources for the task at time point t, It is the calculation rate per unit resource amount.

[0094] The task classification unit includes a classification control processor, a data collection processor and a classification output processor. The classification control processor is used to control the classification process, the data collection processor is used to obtain target information from the monitoring target data table, and the classification output processor classifies the tasks based on the target information and outputs the task code to the resource release adjustment unit or the resource allocation adjustment unit based on the classification result.

[0095] The classification output processor calculates the classification value Cv of the task according to the following formula:

[0096] .

[0097] in, and are the positive conversion coefficient and the reverse conversion coefficient, T R is the running time of the task, and t0 is the starting time point of the utilization function segment.

[0098] When Cv is a positive number, the task code is sent to the resource allocation adjustment unit, and when Cv is a negative number, the task code is sent to the resource release adjustment unit.

[0099] The resource release adjustment unit includes a release calculation processor, a release execution processor and a resource aggregation processor. The release calculation processor is used to calculate the amount of resources released by the task, the release execution processor is used to release the computing power resources of the task, and the resource aggregation processor is used to aggregate the released resources and idle resources and send them to the resource allocation adjustment unit.

[0100] The release calculation processor calculates the amount of resources Rq that the task needs to release according to the following formula:

[0101] .

[0102] Among them, Qa is the amount of resources allocated to the task, and Pm is the reference priority.

[0103] The resource allocation adjustment unit includes an allocation calculation processor and an allocation output processor. The allocation calculation processor is used to calculate the amount of resources newly added to the task, and the allocation output processor is used to generate an allocation instruction and send it to the task execution module.

[0104] The allocation calculation processor calculates the relative weight h of the task according to the following formula:

[0105] .

[0106] Among them, Qu is the resource upper limit of the task.

[0107] The allocation calculation processor calculates the newly allocated resource amount Aq(i) of the i-th task according to the following formula:

[0108] .

[0109] Among them, h(i) represents the relative weight of the i-th task, n is the number of tasks that require additional resources, and Qz is the total amount of allocatable resources.

[0110] The feedback processing unit includes a resource cleaning processor, a data cleaning processor and a result feedback processor. The resource cleaning processor is used to completely release the resources allocated to the task, the data cleaning processor is used to clean up the data left after the task is completed, and the result feedback processor is used to feed back the processing result of the task to the corresponding user.

[0111] The i and j appearing in the above text are both ordinal numbers used to indicate serial numbers.

[0112] The following is part of the code information of this system:

[0113] class Task:

[0114] def __init__(self, task_id, priority, compute_demand):

[0115] self.task_id = task_id

[0116] self.priority = priority

[0117] self.compute_demand = compute_demand

[0118] self.progress = 0

[0119] self.runtime = 0

[0120] self.compute_used = 0

[0121] class QueueManagementModule:

[0122] def __init__(self):

[0123] self.task_queue = []

[0124] def receive_task(self, task):

[0125] # Receive tasks and add them to the queue

[0126] self.task_queue.append(task)

[0127] def sort_tasks(self):

[0128] # Sort by priority

[0129] self.task_queue.sort(key=lambda x: x.priority, reverse=True)

[0130] def output_task(self):

[0131] # Output tasks for execution module to process

[0132] return self.task_queue.pop(0) if self.task_queue else None

[0133] class ProgressMonitoringModule:

[0134] def __init__(self):

[0135] self.monitored_tasks = {}

[0136] def monitor_task(self, task):

[0137] # Add tasks to be monitored

[0138] self.monitored_tasks[task.task_id] = task

[0139] def update_progress(self, task_id, time_increment, compute_increment):

[0140] task = self.monitored_tasks.get(task_id)

[0141] if task:

[0142] task.runtime += time_increment

[0143] task.compute_used += compute_increment

[0144] task.progress = min(1, task.compute_used / task.compute_demand) # Assume allocation based on demand

[0145] def get_monitoring_data(self, task_id):

[0146] task = self.monitored_tasks.get(task_id)

[0147] return {

[0148] 'runtime': task.runtime,

[0149] 'compute_used': task.compute_used,

[0150] 'progress': task.progress

[0151] } if task else None

[0152] class ComputeAdjustmentModule:

[0153] def __init__(self):

[0154] self.tasks_in_execution = []

[0155] def classify_tasks(self, task):

[0156] # Simple example, classify based on monitoring data

[0157] data = progress_module.get_monitoring_data(task.task_id)

[0158] if data['progress'] < 0.5 and data['compute_used'] > data['runtime']:

[0159] return "increase"

[0160] elif data['progress'] > 0.9:

[0161] return "decrease"

[0162] return "stable"

[0163] def adjust_resources(self, task):

[0164] classification = self.classify_tasks(task)

[0165] if classification == "increase":

[0166] self.allocate_more_resources(task)

[0167] elif classification == "decrease":

[0168] self.release_resources(task)

[0169] def allocate_more_resources(self, task):

[0170] print(f"Allocating more resources to task {task.task_id}")

[0171] def release_resources(self, task):

[0172] print(f"Releasing resources for task {task.task_id}")

[0173] class TaskExecutionModule:

[0174] def __init__(self):

[0175] self.current_task = None

[0176] def pair_resource(self, task):

[0177] print(f"Pairing resources with task {task.task_id}")

[0178] self.current_task = task

[0179] def run_task(self):

[0180] if self.current_task:

[0181] print(f"Running task {self.current_task.task_id}")

[0182] # Assume that each execution increases the progress

[0183] progress_module.update_progress(self.current_task.task_id,1, 1)

[0184] def feedback_on_completion(self):

[0185] if self.current_task and self.current_task.progress >= 1:

[0186] print(f"Task {self.current_task.task_id} completed")

[0187] self.current_task = None;

[0188] We now use 10 samples to conduct experiments and test the time required to complete all tasks in the samples under this system and the ordinary system. The results are as follows: Figure 6 As shown in the effect diagram, this system is the experimental group and the ordinary system is the control group.

[0189] The contents disclosed above are only preferred feasible embodiments of the present invention, and do not limit the protection scope of the present invention. Therefore, all equivalent technical changes made using the contents of the present invention specification and drawings are included in the protection scope of the present invention. In addition, the elements therein can be updated as technology develops.

Claims

1. A dynamic computing power allocation system based on task priority, characterized in that: It includes queue management module, progress monitoring module, computing power adjustment module and task execution module; The queue management module is used to receive tasks and sort and manage the tasks, the progress monitoring module is used to monitor and feedback the execution progress of the tasks, the computing power adjustment module is used to adjust and analyze the computing power allocated to the tasks, and the task execution module is used to schedule the computing power to execute the tasks; The queue management module includes a task receiving unit, a queue-jumping processing unit and a task output unit, wherein the task receiving unit is used to receive task information, the queue-jumping processing unit is used to insert tasks into the queue, and the task output unit is used to output tasks in the queue to the task execution module; The progress monitoring module includes a time monitoring unit, a computation amount monitoring unit and a resource utilization monitoring unit. The time monitoring unit is used to monitor the running time of each task, the computation amount monitoring unit is used to monitor the number of calculations of the task, and the resource utilization monitoring unit is used to monitor the utilization of computing power by the task; The computation amount monitoring unit includes a computation counting processor, a progress computing processor and a target updating processor. The computation counting processor is used to count the cumulative computation times of the task in real time. The progress computing processor obtains the progress data according to the computation times. The target updating processor is used to update the progress data and the computation times to the monitoring target data table at the monitoring point. The progress calculation processor calculates the progress value Pg of the task according to the following formula: ； Among them, C all Indicates the total number of calculations required to complete the task, t now represents the current time point, C(t now ) indicates the cumulative number of calculations of the task at the current time point; The resource utilization monitoring unit includes a function segmentation processor, a function calculation processor and a function update processor, wherein the function segmentation processor performs segmentation based on the amount of resources allocated to the task, the function calculation processor is used to calculate the function value of each segment, and the function update processor is used to update the calculated function value into the monitoring target data table; The function calculation processor calculates the utilization function value R(t) of the task in the corresponding segment according to the following formula: ； Among them, C(t) represents the cumulative number of calculations of the task at time point t, is the time precision of the function, V(t) is the amount of resources for the task at time point t, is the calculation rate per unit resource amount; The computing power adjustment module includes a task classification unit, a resource release adjustment unit and a resource allocation adjustment unit; the task classification unit classifies the tasks being executed based on the monitoring data, the resource release adjustment unit is used to release the computing power resources of the tasks, and the resource allocation adjustment unit is used to reallocate the released resources; The task execution module includes a resource pairing unit, a task running unit and a feedback processing unit. The resource pairing unit pairs computing resources with tasks based on allocation information. The task running unit is used to control computing resources to execute tasks. The feedback processing unit is used to perform feedback processing after the task is completed. The queue-jumping processing unit includes a task queue register, a queue-jumping parsing processor, and a task timing processor. The task queue register is used to sort and store tasks. The queue-jumping parsing processor is used to obtain new tasks from the information buffer register and insert them into the task queue. The task timing processor is used to time the time that the task exists in the queue. The queue-jumping analysis processor calculates the task ranking index Sr according to the following formula: ； Among them, T is the time that the task exists in the queue, T0 is the base time, k is the conversion coefficient, and Pr is the priority; The queue-jumping parsing processor inserts a new task into the queue based on the sorting index, so that the sorting indexes of the tasks in the queue are sorted from high to low; The resource release adjustment unit includes a release calculation processor, a release execution processor and a resource aggregation processor, wherein the release calculation processor is used to calculate the amount of resources released by the task, the release execution processor is used to release the computing power resources of the task, and the resource aggregation processor is used to aggregate the released resources and idle resources and send them to the resource allocation adjustment unit; The release calculation processor calculates the amount of resources Rq that the task needs to release according to the following formula: ； Among them, Qa is the amount of resources allocated to the task, Pm is the reference priority, t0 is the starting time point of the utilization function segment, and t now Indicates the current time point; The resource allocation adjustment unit includes an allocation calculation processor and an allocation output processor, wherein the allocation calculation processor is used to calculate the amount of resources newly added to the task, and the allocation output processor is used to generate an allocation instruction and send it to the task execution module; The allocation calculation processor calculates the relative weight h of the task according to the following formula: ； Among them, Qu is the resource upper limit of the task; The allocation calculation processor calculates the newly allocated resource amount Aq(i) of the i-th task according to the following formula: ； Among them, h(i) represents the relative weight of the i-th task, n is the number of tasks that require additional resources, and Qz is the total amount of allocatable resources.

Images