A server computing power allocation system based on multi-agent cooperation

Abstract

This invention discloses a server computing power allocation system based on multi-agent collaboration, comprising: a data processing module for generating server node state information and computing task requirement information; an agent construction module for constructing a set of server node agents and a set of task agents; a feature fusion module for constructing a historical affinity matrix and generating node state vectors and task requirement vectors; an interaction processing module for performing asynchronous information polling and broadcasting to generate multi-agent interaction results; a policy generation module for performing policy reasoning calculations using an improved COMAE collaborative model to generate a server computing power allocation policy matrix; a scheduling and execution module for performing computing task allocation and elastic scheduling of computing resources, and distributing and controlling the execution of computing tasks; and a feedback optimization module for forming server computing power allocation results, achieving collaborative matching between server node states and computing task requirements.

Description

Technical Field

[0001] This invention relates to the field of server resource scheduling, and in particular to a server computing power allocation system based on multi-agent collaboration. Background Technology

[0002] With the rapid development of cloud computing, big data processing, artificial intelligence training, and online business services, server clusters need to simultaneously handle batch processing tasks, real-time computing tasks, model training tasks, and high-concurrency access tasks. Different computing tasks vary significantly in terms of computing resources, memory resources, network bandwidth, execution time, and task priority. Furthermore, the processor utilization, graphics processor utilization, memory usage, network bandwidth usage, task queue length, and node response latency of each server node continuously change as the computing tasks are executed. Therefore, server computing power allocation needs to be adjusted in a dynamic operating environment, based on the real-time operating status of server nodes and the actual resource requirements of the computing tasks, to determine the correspondence between computing tasks and server nodes, as well as the allocation ratio of computing resources.

[0003] Existing server computing power allocation methods typically employ round-robin, minimum load allocation, static weight allocation, or priority scheduling based on preset rules. Round-robin allocation distributes computing tasks to different server nodes in a fixed order; minimum load allocation selects target server nodes based on their current load; static weight allocation determines the task allocation ratio based on pre-defined server node performance weights; and priority scheduling based on preset rules determines the task execution order based on task type, task priority, or task deadline. While these methods have relatively simple structures, they often rely on only a single moment's server node load or the resource requirements of a single computing task for localized judgment. This makes it difficult to simultaneously reflect server node resource availability, load trends, task carrying capacity, and the intensity, urgency, and resource overlap of computing task resource requirements. This can easily lead to some server nodes experiencing sustained high loads while the computing resources of other server nodes are underutilized. Summary of the Invention

[0004] One objective of this invention is to propose a server computing power allocation system based on multi-agent collaboration. This invention fully utilizes server state awareness, multi-agent interaction, historical collaboration relationship fusion, resource competition analysis, and an improved COMAE collaboration model, and has the advantages of high computing power resource utilization, high task allocation accuracy, low resource contention, and strong dynamic adaptability.

[0005] A server computing power allocation system based on multi-agent collaboration according to an embodiment of the present invention includes:

[0006] The data processing module is used to preprocess running status data and task attribute data, and generate server node status information and computing task requirement information.

[0007] The agent construction module is used to construct a set of server node agents based on server node status information and a set of task agents based on computing task requirement information.

[0008] The feature fusion module is used to fuse and embed the historical collaboration frequency between nodes and the resource competition coefficient between tasks based on the server node intelligent agent set and the task intelligent agent set, to construct a historical affinity matrix and generate node state vector and task demand vector.

[0009] The interaction processing module is used to construct a multi-agent interaction environment based on node state vectors and task requirement vectors, and to perform asynchronous information polling and broadcasting to generate multi-agent interaction results.

[0010] The strategy generation module is used to input the multi-agent interaction results into the improved COMAE collaborative model for strategy reasoning and calculation, and generate the server computing power allocation strategy matrix.

[0011] The scheduling and execution module is used to allocate computing tasks and perform elastic scheduling of computing resources according to the server computing power allocation strategy matrix, and to distribute and control the execution of computing tasks.

[0012] The feedback optimization module is used to collect real-time performance feedback data and resource contention conflict records during the execution of computing tasks. It uses counterfactual baseline multi-step temporal difference to calculate the decision response values ​​of each agent's actions and asynchronously updates the parameters of the improved COMAE collaborative model to form the server computing power allocation results.

[0013] Optionally, processor utilization, graphics processor utilization, memory usage, storage read / write speed, network bandwidth usage, task queue length, node response latency, and node fault status of each server node are collected according to a unified sampling period to form runtime status data. The task type, computing power requirement, memory requirement, network bandwidth requirement, estimated execution time, task priority, task deadline, and task dependencies of each computing task are obtained to form task attribute data. Missing value completion, outlier correction, and normalization processing are performed on the runtime status data. Field parsing, type conversion, priority encoding, and task dependency marking are performed on the task attribute data to generate server node status information and computing task requirement information.

[0014] Optionally, the intelligent agent construction module includes:

[0015] Based on the server node status information, extract the resource reserves, load change trends and task carrying capacity of each server node, and encode the collaborative roles to generate a set of server node status features.

[0016] Each server node is used as a server node agent. The corresponding server node state features in the server node state feature set are written into the corresponding server node agent to generate a server node agent set.

[0017] Based on the computing task requirement information, the resource requirement intensity, execution urgency and resource overlap of each computing task are extracted, and the competitive roles are encoded to generate a set of computing task requirement features.

[0018] Each computing task is used as a task agent. The corresponding computing task requirement features in the set of computing task requirement features are written into the corresponding task agent to generate a set of task agents.

[0019] Optionally, the feature fusion module includes:

[0020] The server node state features in the server node agent set and the computational task requirement features in the task agent set are vectorized to generate initial node state vectors and initial task requirement vectors.

[0021] The historical collaboration frequency is calculated based on the computing task collaboration records of each server node intelligent agent pair, and the resource competition coefficient is calculated based on the degree of overlap in computing resource requirements of each task intelligent agent pair.

[0022] Based on the historical collaboration frequency and resource competition coefficient, the historical affinity between each server node agent and each task agent is determined, a historical affinity matrix is ​​constructed, and the historical affinity matrix is ​​normalized to generate task fusion weights and node fusion weights.

[0023] Based on the task fusion weight, the initial task requirement vector is injected into the initial node state vector in a targeted manner, and residual coupling is performed to generate the node state vector. Based on the node fusion weight, the initial node state vector is injected into the initial task requirement vector in a targeted manner, and residual coupling is performed to generate the task requirement vector.

[0024] Optionally, the interaction processing module includes:

[0025] Write the node state vector into the corresponding server node agent, write the task requirement vector into the corresponding task agent, and establish the interaction connection between the server node agent and the task agent based on the historical affinity matrix to build a multi-agent interaction environment.

[0026] Based on the load change trend of each server node agent and the execution urgency of each task agent, the information polling priority is determined, and an asynchronous polling sequence is generated according to the information polling priority.

[0027] Read the node state vector of each server node agent and the task requirement vector of each task agent in sequence according to the asynchronous polling sequence, and generate agent broadcast information.

[0028] Send agent broadcast information along the interaction connection, filter and aggregate the agent broadcast information, and generate an interaction state vector;

[0029] The interaction state vectors are summarized according to the correspondence between the server node agents and the task agents to generate multi-agent interaction results.

[0030] Optionally, the strategy generation module includes:

[0031] The results of multi-agent interaction are input into the improved COMAE collaborative model for policy reasoning calculation. The improved COMAE collaborative model includes a time-stamped trajectory calibration module, a group utility decoupling module, an action surrogate evaluation module, and a boundary constraint projection module. The improvement of the improved COMAE collaborative model is as follows: the traditional COMAE collaborative model obtains the overall decision benefit corresponding to the joint action through centralized value evaluation to determine the contribution of each agent's action to the overall decision. The improved COMAE collaborative model performs time-stamped calibration based on the generation time, arrival time, and state change amplitude of the interaction state vector. It separates and reconstructs the local utility components through the mirror barrier penetration mechanism, evaluates the independent contribution of each agent's action through the action surrogate method, and performs boundary correction on the surrogate contribution value in combination with computing power resources, memory resources, network bandwidth, and execution time limit to generate a server computing power allocation strategy matrix that matches the server cluster's operating status and computing task requirements.

[0032] In the time-stamped trajectory calibration module, based on the generation time, arrival time and state change amplitude between adjacent interactive state vectors in the multi-agent interaction results, a time-series offset ridge is constructed, and segmented traction calibration and missing state backfilling are performed on each interactive state vector according to the time-series offset ridge to generate a time-stamped calibration interaction sequence.

[0033] In the group utility decoupling module, the local utility components corresponding to the server node agent and the task agent are separated according to the time-stamped calibration interaction sequence. A mirror barrier penetration mechanism is introduced. The local utility components are reverse-mapped with the group utility center as the mirror reference to generate mirror utility components. A utility barrier is constructed according to the utility difference between the local utility components and the mirror utility components. The utility penetration direction and utility penetration intensity are determined according to the continuous change of the utility barrier. The local utility components after penetration are rearranged according to the utility penetration intensity to generate a barrier utility representation.

[0034] In the action surrogate evaluation module, surrogate actions are generated for each server node agent and task agent based on the barrier utility representation. The current action of the corresponding agent is replaced by the surrogate action, and the surrogate contribution value is generated based on the difference of local utility components before and after the action replacement.

[0035] In the boundary constraint projection module, a boundary constraint interval is constructed based on the computing power resources, memory resources, network bandwidth, and execution time limits of each computing task of each server node. The substitute contribution value located outside the boundary constraint interval is bounced back along the corresponding boundary direction and alternately corrected to generate a boundary correction contribution value. The allocation weight and computing power resource allocation ratio between each computing task and each server node are determined based on the boundary correction contribution value. The computing power allocation strategy matrix is ​​generated by arranging the computing task identifier and server node identifier in a matrix.

[0036] Optionally, the scheduling execution module includes:

[0037] Read the allocation weights and computing resource allocation ratios from the server computing power allocation strategy matrix to determine the scheduling priority of computing tasks;

[0038] The computing tasks are arranged according to their scheduling priority, and the corresponding server nodes are determined based on the allocation weight of each computing task to generate the computing task allocation results.

[0039] Based on the computing task allocation results, determine the computing resource scheduling amount corresponding to each computing task and generate computing resource scheduling results.

[0040] Based on the computing resource scheduling results, a computing task issuance instruction is generated and sent to the corresponding server node for execution control.

[0041] Optionally, the feedback optimization module includes:

[0042] Collect real-time performance feedback data and resource contention conflict records during the execution of each computing task, and generate a task execution feedback sequence;

[0043] The task execution feedback sequence is continuously segmented according to the collection time to generate a multi-step feedback state sequence;

[0044] Based on the multi-step feedback state sequence, the counterfactual baseline multi-step temporal difference method is adopted to calculate the multi-step benefit difference between the corresponding actions of each server node agent and each task agent in the continuous acquisition time, and generate the decision response value of the corresponding agent action.

[0045] The parameter update order of the corresponding agent is determined based on the decision response value of each agent's action. The parameters of the improved COMAE collaborative model are updated asynchronously to form a closed-loop optimized server computing power allocation result.

[0046] The beneficial effects of this invention are:

[0047] This invention unifies the processing of server node operational status data and computation task attribute data, constructing separate sets of server node agents and task agents. It then builds a historical affinity matrix by combining the historical collaboration frequency between server nodes and the resource competition coefficient between computation tasks, enabling the association between server node states and computation task requirements within a unified multi-agent environment. By generating node state vectors and task requirement vectors based on the historical affinity matrix and employing asynchronous polling and broadcasting for multi-agent interaction, it reduces synchronization waits and invalid information transmission, improving the matching degree between server node state information and computation task requirement information. This, in turn, enhances the accuracy of computation task allocation and the utilization efficiency of server cluster computing resources.

[0048] This invention improves the COMAE collaborative model to perform policy reasoning on the interaction results of multiple agents, generating a server computing power allocation strategy matrix. Based on this matrix, it completes the scheduling of computing tasks, allocation of computing resources, and task distribution. Simultaneously, by combining real-time performance feedback data and resource contention conflict records during task execution, it calculates the decision response values ​​of each agent's actions and asynchronously updates the parameters of the improved COMAE collaborative model, creating a closed-loop optimization of the server computing power allocation process. This reduces computing resource contention and server node load imbalance, decreases task execution latency and task migration frequency, and improves the system's dynamic adaptability to changes in server node status and computing task demands. Attached Figure Description

[0049] The accompanying drawings are provided to further illustrate the invention and form part of the specification. They are used in conjunction with embodiments of the invention to explain the invention and do not constitute a limitation thereof. In the drawings:

[0050] Figure 1 This is an overall flowchart of a server computing power allocation system based on multi-agent collaboration proposed in this invention;

[0051] Figure 2 This is a schematic diagram of the structure of an improved COMAE collaborative model for a server computing power allocation system based on multi-agent collaboration proposed in this invention. Detailed Implementation

[0052] The present invention will now be described in further detail with reference to the accompanying drawings. These drawings are simplified schematic diagrams, illustrating only the basic structure of the invention, and therefore only show the components relevant to the invention.

[0053] refer to Figures 1-2 A server computing power allocation system based on multi-agent collaboration includes:

[0054] The data processing module is used to preprocess running status data and task attribute data, and generate server node status information and computing task requirement information.

[0055] The agent construction module is used to construct a set of server node agents based on server node status information and a set of task agents based on computing task requirement information.

[0056] The feature fusion module is used to fuse and embed the historical collaboration frequency between nodes and the resource competition coefficient between tasks based on the server node intelligent agent set and the task intelligent agent set, to construct a historical affinity matrix and generate node state vector and task demand vector.

[0057] The interaction processing module is used to construct a multi-agent interaction environment based on node state vectors and task requirement vectors, and to perform asynchronous information polling and broadcasting to generate multi-agent interaction results.

[0058] The strategy generation module is used to input the multi-agent interaction results into the improved COMAE collaborative model for strategy reasoning and calculation, and generate the server computing power allocation strategy matrix.

[0059] The scheduling and execution module is used to allocate computing tasks and perform elastic scheduling of computing resources according to the server computing power allocation strategy matrix, and to distribute and control the execution of computing tasks.

[0060] The feedback optimization module is used to collect real-time performance feedback data and resource contention conflict records during the execution of computing tasks. It uses counterfactual baseline multi-step temporal difference to calculate the decision response values ​​of each agent's actions and asynchronously updates the parameters of the improved COMAE collaborative model to form the server computing power allocation results.

[0061] In this embodiment, processor utilization, graphics processor utilization, memory usage, storage read / write speed, network bandwidth usage, task queue length, node response latency, and node fault status of each server node are collected according to a unified sampling period to form runtime status data. The task type, computing power requirement, memory requirement, network bandwidth requirement, estimated execution time, task priority, task deadline, and task dependencies of each computing task are obtained to form task attribute data. Missing value completion, outlier correction, and normalization processing are performed on the runtime status data. Field parsing, type conversion, priority encoding, and task dependency marking are performed on the task attribute data to generate server node status information and computing task requirement information.

[0062] In this embodiment, the agent construction module includes:

[0063] Based on the server node status information, extract the resource reserves, load change trends and task carrying capacity of each server node, and encode the collaborative roles to generate a set of server node status features.

[0064] The process of generating the server node status feature set is as follows: Extract processor utilization, graphics processor utilization, memory usage, storage read / write speed, network bandwidth usage, task queue length, node response latency, and node fault status from the server node status information. Determine resource reserves based on the usage of processors, graphics processors, memory, storage, and network bandwidth. Arrange processor utilization, graphics processor utilization, memory usage, storage read / write speed, network bandwidth usage, and task queue length according to the collection time, and determine the load change trend based on the changes in corresponding data at adjacent collection times. Determine task carrying capacity by combining resource reserves, load change trends, task queue length, node response latency, and node fault status. Based on the resource reserves, task carrying capacity, and load change trends, encode each server node into a task receiving role, a collaborative sharing role, or a task limiting role, completing the collaborative role encoding. Merge the resource reserves, load change trends, task carrying capacity, and collaborative role encoding results corresponding to each server node to generate the corresponding server node status features, and summarize all server node status features into a server node status feature set.

[0065] Each server node is used as a server node agent. The corresponding server node state features in the server node state feature set are written into the corresponding server node agent to generate a server node agent set.

[0066] The specific process for generating the server node agent set is as follows: Each server node is used as a server node agent, and a corresponding server node identifier is set for each server node agent; according to the server node identifier, the server node state features corresponding to each server node are extracted from the server node state feature set, and the server node state features are written into the corresponding server node agent, so that each server node agent carries the corresponding resource reserve, load change trend, task carrying capacity, and collaborative role coding results; all server node agents are summarized according to the server node identifier to generate the server node agent set.

[0067] Based on the computing task requirement information, the resource requirement intensity, execution urgency and resource overlap of each computing task are extracted, and the competitive roles are encoded to generate a set of computing task requirement features.

[0068] The specific process for generating the computation task requirement feature set is as follows: Extract the computational power requirement, memory requirement, network bandwidth requirement, estimated execution time, task priority, task deadline, and task dependencies corresponding to each computation task from the computation task requirement information; determine the resource requirement intensity of each computation task based on the computational power requirement, memory requirement, and network bandwidth requirement; determine the execution urgency of each computation task based on the estimated execution time, task priority, and task deadline; determine the degree of resource overlap based on the overlap of computational power requirement, memory requirement, and network bandwidth requirement between different computation tasks; based on the resource requirement intensity, execution urgency, and resource overlap, encode each computation task into a priority competition role, a cooperative waiting role, or a normal execution role, completing the competition role encoding; merge the resource requirement intensity, execution urgency, resource overlap, and competition role encoding results corresponding to each computation task to generate the corresponding computation task requirement features; and summarize all computation task requirement features into a computation task requirement feature set.

[0069] Each computing task is used as a task agent. The corresponding computing task requirement features in the set of computing task requirement features are written into the corresponding task agent to generate a set of task agents.

[0070] The process of generating the task agent set is as follows: each computing task is used as a task agent, and a corresponding computing task identifier is set for each task agent; according to the computing task identifier, the computing task requirement features corresponding to each computing task are extracted from the computing task requirement feature set, and the computing task requirement features are written into the corresponding task agent, so that each task agent carries the corresponding resource requirement intensity, execution urgency, resource overlap degree and competition role coding result; all task agents are summarized according to the computing task identifier to generate the task agent set.

[0071] In this embodiment, the feature fusion module includes:

[0072] The server node state features in the server node agent set and the computational task requirement features in the task agent set are vectorized to generate initial node state vectors and initial task requirement vectors.

[0073] The initial node state vector and initial task requirement vector are generated as follows: From the server node agent set, the resource availability, load change trend, task carrying capacity, and collaborative role coding results of each server node agent are read. The corresponding values ​​are arranged in the order of resource availability, load change trend, task carrying capacity, and collaborative role coding results. Each value is normalized, and the normalized values ​​are concatenated sequentially to generate the initial node state vector for each server node agent. From the task agent set, the resource requirement intensity, execution urgency, resource overlap, and competitive role coding results of each task agent are read. The corresponding values ​​are arranged in the order of resource requirement intensity, execution urgency, resource overlap, and competitive role coding results. Each value is normalized, and the normalized values ​​are concatenated sequentially to generate the initial task requirement vector for each task agent.

[0074] The historical collaboration frequency is calculated based on the computing task collaboration records of each server node intelligent agent pair, and the resource competition coefficient is calculated based on the degree of overlap in computing resource requirements of each task intelligent agent pair.

[0075] The calculation process for historical collaboration frequency and resource competition coefficient is as follows: Read the computation task collaboration records of each server node agent pair, count the number of times the corresponding server node agents jointly execute computation tasks and the total number of times they execute computation tasks separately, divide the number of times they jointly execute computation tasks by the difference between the sum of the total number of times the corresponding server node agents execute computation tasks and the number of times they jointly execute computation tasks to obtain the historical collaboration frequency of each server node agent pair; read the computing power requirement, memory requirement, and network bandwidth requirement corresponding to each task agent, determine the overlapping requirement and maximum requirement of each task agent pair on the same type of computing power resource, accumulate the overlapping requirement corresponding to each type of computing power resource, and accumulate the maximum requirement corresponding to each type of computing power resource, divide the result of the accumulated overlapping requirement by the result of the accumulated maximum requirement to obtain the resource competition coefficient of each task agent pair;

[0076] Based on the historical collaboration frequency and resource competition coefficient, the historical affinity between each server node agent and each task agent is determined, a historical affinity matrix is ​​constructed, and the historical affinity matrix is ​​normalized to generate task fusion weights and node fusion weights.

[0077] The process for generating task fusion weights and node fusion weights is as follows: Calculate the average historical collaboration frequency for each server node agent and the average resource competition coefficient for each task agent. When the average historical collaboration frequency for server node agents A, B, and C are 0.80, 0.65, and 0.50 respectively, and the average resource competition coefficient for task agents A, B, and C are 0.20, 0.35, and 0.50 respectively, then, according to the ratio of the average historical collaboration frequency (0.60) to the average resource competition coefficient (0.40), subtract one from the average historical collaboration frequency. The results after removing the average of the resource competition coefficients are weighted and combined to obtain the historical affinity between each server node agent and each task agent. All historical affinity values ​​are arranged according to the corresponding order of server node agents and task agents to construct a historical affinity matrix. The historical affinity between each server node agent and all task agents is normalized so that the sum of the corresponding task fusion weights is 1, thus obtaining the task fusion weight for each task agent. The historical affinity between each task agent and all server node agents is normalized so that the sum of the corresponding node fusion weights is 1, thus obtaining the node fusion weight for each server node agent.

[0078] Based on the task fusion weight, the initial task requirement vector is injected into the initial node state vector in a targeted manner, and residual coupling is performed to generate the node state vector. Based on the node fusion weight, the initial node state vector is injected into the initial task requirement vector in a targeted manner, and residual coupling is performed to generate the task requirement vector.

[0079] The generation process of node state vector and task requirement vector is as follows: For each server node agent, select vector components from each initial task requirement vector according to the corresponding task fusion weight, and multiply each vector component by the corresponding task fusion weight and then sum them to obtain the task requirement injection vector; add the task requirement injection vector to the corresponding initial node state vector item by item according to the same vector dimension to generate the node state vector of the corresponding server node agent; for each task agent, select vector components from each initial node state vector according to the corresponding node fusion weight, and multiply each vector component by the corresponding node fusion weight and then sum them to obtain the node state injection vector; add the node state injection vector to the corresponding initial task requirement vector item by item according to the same vector dimension to generate the task requirement vector of the corresponding task agent.

[0080] In this embodiment, the interaction processing module includes:

[0081] Write the node state vector into the corresponding server node agent, write the task requirement vector into the corresponding task agent, and establish the interaction connection between the server node agent and the task agent based on the historical affinity matrix to build a multi-agent interaction environment.

[0082] The construction process of the multi-agent interaction environment is as follows: According to the correspondence between server node agents and task agents, the node state vector is written into the corresponding server node agent, and the task requirement vector is written into the corresponding task agent; the historical affinity between each server node agent and each task agent is read from the historical affinity matrix, and interactive connections are established between server node agents with historical affinity greater than a preset connection threshold and task agents. The preset connection threshold is 0.43; the server node agents, task agents, and interactive connections are associated, and the node state vector, task requirement vector, and historical affinity matrix are used as interactive information to construct the multi-agent interaction environment.

[0083] Based on the load change trend of each server node agent and the execution urgency of each task agent, the information polling priority is determined, and an asynchronous polling sequence is generated according to the information polling priority.

[0084] The asynchronous polling sequence is generated as follows: read the load change trend of each server node agent and the execution urgency of each task agent; sort the server node agents according to the load change magnitude from large to small, and sort the task agents according to the execution urgency from high to low; arrange the sorted server node agents and task agents alternately in sequence; arrange server node agents with the same load change trend according to the server node identifier, and arrange task agents with the same execution urgency according to the computation task identifier to generate the asynchronous polling sequence.

[0085] Read the node state vector of each server node agent and the task requirement vector of each task agent in sequence according to the asynchronous polling sequence, and generate agent broadcast information.

[0086] The process of generating agent broadcast information is as follows: The server node agent or task agent to be polled is determined sequentially according to the asynchronous polling sequence. When the current polling object is a server node agent, the server node identifier, node state vector, and corresponding historical affinity from the historical affinity matrix of the corresponding server node agent are read and encapsulated in the order of server node identifier, node state vector, and historical affinity to generate the agent broadcast information corresponding to the server node agent. When the current polling object is a task agent, the computation task identifier, task requirement vector, and corresponding historical affinity from the historical affinity matrix of the corresponding task agent are read and encapsulated in the order of computation task identifier, task requirement vector, and historical affinity to generate the agent broadcast information corresponding to the task agent.

[0087] Send agent broadcast information along the interaction connection, filter and aggregate the agent broadcast information, and generate an interaction state vector;

[0088] The process of generating the interaction state vector is as follows: The agent broadcast information corresponding to each server node agent and task agent is sent along the interaction connection to the server node agent or task agent with which it has established an interaction connection; the server node identifier or task identifier, node state vector or task requirement vector, and corresponding historical affinity are read from the received agent broadcast information; the average historical affinity of all corresponding historical affinity is calculated, and agent broadcast information with historical affinity less than the average historical affinity is deleted; the remaining agent broadcast information is arranged from high to low according to the historical affinity; the corresponding node state vector or task requirement vector is accumulated item by item according to the proportion of each historical affinity to the total of the remaining historical affinity; the accumulated result is concatenated with the receiving agent's own node state vector or task requirement vector to generate the interaction state vector of the corresponding server node agent or task agent.

[0089] The interaction state vectors are summarized according to the correspondence between the server node agents and the task agents to generate multi-agent interaction results.

[0090] In this embodiment, the strategy generation module includes:

[0091] The results of multi-agent interaction are input into the improved COMAE collaborative model for policy reasoning calculation. The improved COMAE collaborative model includes a time-stamped trajectory calibration module, a group utility decoupling module, an action surrogate evaluation module, and a boundary constraint projection module. The improvement of the improved COMAE collaborative model is as follows: the traditional COMAE collaborative model obtains the overall decision benefit corresponding to the joint action through centralized value evaluation to determine the contribution of each agent's action to the overall decision. The improved COMAE collaborative model performs time-stamped calibration based on the generation time, arrival time, and state change amplitude of the interaction state vector. It separates and reconstructs the local utility components through the mirror barrier penetration mechanism, evaluates the independent contribution of each agent's action through the action surrogate method, and performs boundary correction on the surrogate contribution value in combination with computing power resources, memory resources, network bandwidth, and execution time limit to generate a server computing power allocation strategy matrix that matches the server cluster's operating status and computing task requirements.

[0092] The improved COMAE collaborative model is sequentially connected as follows: time-scaled trajectory calibration module, group utility decoupling module, action surrogate evaluation module, and boundary constraint projection module. Multi-agent interaction results are input into the time-scaled trajectory calibration module in a sequence format containing agent identifiers, interaction state vectors, generation time, and arrival time, forming a time-scaled calibration interaction sequence with a dimension equal to the number of agents multiplied by the dimension of the interaction state vector. This time-scaled calibration interaction sequence is input into the group utility decoupling module, forming a barrier utility representation corresponding to the number of agents. The barrier utility representation is input into the action surrogate evaluation module, forming a one-dimensional surrogate contribution value for each agent. The surrogate contribution value is input into the boundary constraint projection module, and a server computing power allocation strategy matrix is ​​output in a matrix format equal to the number of computational tasks multiplied by the number of server nodes.

[0093] The training data for the improved COMAE collaborative model comes from the historical operation records and simulation scheduling records of the server cluster, including multi-agent interaction results, server computing power allocation strategy matrix, real-time performance feedback data, and resource contention conflict records. The overall decision benefit is labeled for each computing power allocation process based on whether the computing task is completed within the execution time limit, server node resource utilization, number of resource contention conflicts, and number of task migrations. The substitute contribution value is labeled based on the difference in overall decision benefit before and after the replacement of each agent's action. During training, a joint loss is constructed, consisting of policy inference loss, utility decoupling loss, time-scale calibration loss, surrogate contribution loss, and boundary constraint loss. The policy inference loss reduces the difference between predicted and labeled allocation weights; the utility decoupling loss limits the deviation between the sum of local utility components and the overall decision benefit; the time-scale calibration loss reduces the temporal offset of adjacent interaction state vectors before and after calibration; the surrogate contribution loss reduces the difference between predicted and labeled surrogate contribution values; and the boundary constraint loss penalizes matrix elements in the server computing power allocation policy matrix that violate computing power resources, memory resources, network bandwidth, and execution time limits. The weights of the policy inference loss, utility decoupling loss, time-scale calibration loss, surrogate contribution loss, and boundary constraint loss in the joint loss are set to 0.35, 0.20, 0.15, 0.20, and 0.15, respectively.

[0094] A phased alternating training approach is adopted. First, the boundary constraint projection parameters are fixed and the remaining parameters are trained. Then, the boundary constraint projection parameters are fixed and the remaining parameters are trained. Parameter alternation is performed every 5 rounds of training. The initial learning rate is set to 0.001, the batch size is set to 32, the discount factor is set to 0.95, the upper limit of the gradient norm is set to 5, and the maximum number of training rounds is set to 300. If the joint loss does not decrease for every 20 consecutive rounds, the learning rate is adjusted to 50% of the current learning rate. When the joint loss on the validation set does not decrease for 15 consecutive rounds, the improved COMAE collaborative model is considered to have reached convergence, and the model parameters corresponding to the round with the minimum joint loss on the validation set are saved.

[0095] In the time-stamped trajectory calibration module, based on the generation time, arrival time and state change amplitude between adjacent interaction state vectors in the multi-agent interaction results, a time-series offset ridge is constructed, and segmented traction calibration and missing state backfilling are performed on each interaction state vector according to the time-series offset ridge to generate a time-stamped calibration interaction sequence.

[0096] The generation process of the time-stamped calibration interaction sequence is as follows: The generation and arrival times of each interaction state vector are read from the multi-agent interaction results. The generation time is subtracted from the arrival time to obtain the temporal offset corresponding to each interaction state vector. The interaction state vectors are arranged according to their generation times. The differences between the vector components of adjacent interaction state vectors are calculated, and the state change amplitude is determined based on these differences. The temporal offsets and state change amplitudes corresponding to each interaction state vector are connected sequentially according to their generation times to construct a temporal offset ridge. Based on the continuous changes in the temporal offsets and state change amplitudes within the temporal offset ridge, the time-stamped calibration interaction sequence is... Each interactive state vector is divided into calibration segments. Within each calibration segment, the arrangement of each interactive state vector is adjusted based on the generation time. The corresponding interactive state vector is then calibrated segmentally according to the time offset difference between adjacent interactive state vectors. The positions in each calibration segment where there are no consecutive interactive state vectors corresponding to the generation time are identified. The missing vector components are determined based on the change ratio of the same vector components in adjacent interactive state vectors before and after the position, and the missing vector components are written into the corresponding positions to complete the missing state backfilling. All interactive state vectors are arranged sequentially according to the calibrated generation times to generate a time-stamped calibration interactive sequence.

[0097] In the group utility decoupling module, the local utility components corresponding to the server node agent and the task agent are separated according to the time-stamped calibration interaction sequence. A mirror barrier penetration mechanism is introduced. The local utility components are reverse-mapped with the group utility center as the mirror reference to generate mirror utility components. A utility barrier is constructed according to the utility difference between the local utility components and the mirror utility components. The utility penetration direction and utility penetration intensity are determined according to the continuous change of the utility barrier. The local utility components after penetration are rearranged according to the utility penetration intensity to generate a barrier utility representation.

[0098] The generation process of the barrier utility representation is as follows: Interaction state vectors corresponding to the server node agent and the task agent are extracted from the time-stamped calibration interaction sequence, and local utility components are obtained based on the degree of influence of each interaction state vector on the overall decision benefit; the average value of all local utility components is calculated to obtain the group utility center; a mirror barrier penetration mechanism is introduced, using the group utility center as a symmetric reference, the differences between each local utility component and the group utility center are superimposed back onto the group utility center to generate the corresponding mirror utility component; the difference between each local utility component and its corresponding mirror utility component is calculated. The absolute value of the difference is used to obtain the utility gap, and each utility gap is connected according to the arrangement order in the time-scaled calibration interaction sequence to construct a utility barrier. The changing directions of adjacent utility barriers are compared, and the direction in which the utility barrier continuously decreases is determined as the utility penetration direction. The utility penetration intensity is determined according to the proportion of the difference between the current utility barrier and the adjacent utility barriers to the sum of the differences of all utility barriers. The arrangement position of each local utility component is adjusted according to the utility penetration direction, and the corresponding local utility component is scaled according to the utility penetration intensity. All the adjusted local utility components are spliced ​​together in sequence to generate a barrier utility representation.

[0099] In the action surrogate evaluation module, surrogate actions are generated for each server node agent and task agent based on the barrier utility representation. The current action of the corresponding agent is replaced by the surrogate action, and the surrogate contribution value is generated based on the difference of local utility components before and after the action replacement.

[0100] The process of generating the substitute contribution value is as follows: Extract the local utility components corresponding to each server node agent and task agent from the barrier utility representation, and read the current action of the corresponding agent; for each server node agent, set the task reception quantity of the corresponding computation task in the current action to zero, and keep the current actions of other server node agents and task agents unchanged, and generate the substitute action corresponding to the server node agent; for each task agent, reset the node selection weight of the corresponding server node in the current action to zero, and keep the current actions of other task agents and server node agents unchanged, and generate the substitute action corresponding to the task agent; calculate the corresponding local utility components based on the current action and the substitute action respectively, and subtract the local utility component corresponding to the substitute action from the local utility component corresponding to the current action to generate the substitute contribution value of the corresponding server node agent or task agent;

[0101] In the boundary constraint projection module, a boundary constraint interval is constructed based on the computing power resources, memory resources, network bandwidth, and execution time limits of each computing task of each server node. The substitute contribution value located outside the boundary constraint interval is bounced back along the corresponding boundary direction and alternately corrected to generate a boundary correction contribution value. The allocation weight and computing power resource allocation ratio between each computing task and each server node are determined based on the boundary correction contribution value. The computing power allocation strategy matrix is ​​generated by arranging the computing task identifier and server node identifier in a matrix.

[0102] The generation process of the server computing power allocation strategy matrix is ​​as follows: Read the computing power resources, memory resources, and network bandwidth of each server node, as well as the computing power requirements, memory requirements, network bandwidth requirements, and execution time limits of each computing task, and construct boundary constraint intervals according to the value range of the corresponding resources; compare the surrogate contribution values ​​corresponding to each server node agent and each task agent with the boundary constraint intervals respectively; for surrogate contribution values ​​located outside the boundary constraint intervals, perform a reverse bounce along the inner side of the boundary according to the distance between them and the corresponding boundary; and finally, according to the computing power resources, memory resources, network bandwidth, and execution time limits... The process involves repeated sequential comparisons and reverse bounces until all substitute contribution values ​​are within the corresponding boundary constraint intervals, generating boundary correction contribution values. All boundary correction contribution values ​​corresponding to the same computational task are normalized to generate allocation weights between the computational task and each server node. The allocation ratio of computational resources is determined based on the allocation weights, the computational power requirements of the computational task, and the computational resources of the corresponding server nodes. The allocation weights and computational resource allocation ratios are written into the corresponding matrix positions, with the computational task identifier corresponding to the matrix row and the server node identifier corresponding to the matrix column, generating a server computational power allocation strategy matrix.

[0103] In this embodiment, the scheduling execution module includes:

[0104] Read the allocation weights and computing resource allocation ratios from the server computing power allocation strategy matrix to determine the scheduling priority of computing tasks;

[0105] The process of determining the scheduling priority of computing tasks is as follows: The allocation weights and computing resource allocation ratios between each computing task and each server node are read from the server computing power allocation strategy matrix. The sum of all allocation weights and the sum of all computing resource allocation ratios corresponding to the same computing task are calculated separately, and these sums are normalized. The normalized sums of allocation weights and computing resource allocation ratios are then added together to obtain the scheduling score for each computing task. The computing tasks are then arranged in descending order of their scheduling scores, and this order is determined as the computing task scheduling priority for the corresponding computing task.

[0106] The computing tasks are arranged according to their scheduling priority, and the corresponding server nodes are determined based on the allocation weight of each computing task to generate the computing task allocation results.

[0107] The process of generating the computation task allocation result is as follows: Each computation task is read sequentially from high to low according to its scheduling priority, and the allocation weight between the current computation task and each server node is extracted from the server computing power allocation strategy matrix; the server nodes are arranged from largest to smallest according to their allocation weights, and the server node with the largest allocation weight is determined as the server node corresponding to the current computation task; when multiple server nodes have the same allocation weight, the corresponding server node is determined according to the order of their identifiers; the computation task identifier, computation task scheduling priority, server node identifier, and corresponding allocation weight of each computation task are associated to generate the computation task allocation result.

[0108] Based on the computing task allocation results, determine the computing resource scheduling amount corresponding to each computing task and generate computing resource scheduling results.

[0109] The process of generating computing resource scheduling results is as follows: Read the server nodes and corresponding allocation weights for each computing task from the computing task allocation results, and read the corresponding computing resource allocation ratios from the server computing power allocation strategy matrix; process each computing task sequentially according to its scheduling priority, multiplying the schedulable computing resources of the corresponding server node by the corresponding computing resource allocation ratio to obtain the initial computing resource scheduling amount for each computing task; accumulate all the initial computing resource scheduling amounts corresponding to the same server node, and compare the accumulated result with the schedulable computing resources of the server node; when the accumulated result is greater than the schedulable computing resources, compress the initial computing resource scheduling amount according to the proportion of each computing task's corresponding allocation weight to the total allocation weight; when the accumulated result is less than the schedulable computing resources, keep the initial computing resource scheduling amount unchanged; associate the adjusted computing resource scheduling amount for each computing task with the server node identifier of the corresponding server node to generate the computing resource scheduling result.

[0110] Based on the computing resource scheduling results, a computing task issuance instruction is generated and sent to the corresponding server node for execution control.

[0111] The process of generating computation task issuance instructions is as follows: read the computation task identifier, the server node identifier of the corresponding server node, and the computation resource allocation amount of each computation task from the computation resource scheduling results, and determine the issuance order of each computation task according to the computation task scheduling priority; write the computation task identifier, server node identifier, computation resource allocation amount, and issuance order into the instruction field in sequence to generate the computation task issuance instructions corresponding to each computation task.

[0112] In this embodiment, the feedback optimization module includes:

[0113] Collect real-time performance feedback data and resource contention conflict records during the execution of each computing task, and generate a task execution feedback sequence;

[0114] The process of generating the task execution feedback sequence is as follows: During the execution of each computing task, the computing resource utilization rate, memory resource utilization rate, network bandwidth utilization rate, computing task execution progress, and computing task execution latency of the corresponding server node are collected according to a preset collection cycle to form real-time performance feedback data. The collection time and duration of computing resource contention, memory resource contention, and network bandwidth contention between computing tasks in the same server node are recorded to form a resource contention conflict record. The real-time performance feedback data and the resource contention conflict record are associated with each other according to the computing task identifier and the server node identifier, and arranged in sequence according to the collection time to generate the task execution feedback sequence.

[0115] The task execution feedback sequence is continuously segmented according to the collection time to generate a multi-step feedback state sequence;

[0116] The process of generating a multi-step feedback state sequence is as follows: The task execution feedback sequence is read from first to last according to the acquisition time, and multiple consecutive acquisition times are considered as one feedback state segment. The computing resource utilization, memory resource utilization, network bandwidth utilization, computing task execution progress, computing task execution latency, resource contention type, and contention duration within each feedback state segment are arranged sequentially according to the acquisition time. Some overlapping acquisition times are retained between adjacent feedback state segments, and the correspondence between various data is maintained according to the computing task identifier and the server node identifier. All feedback state segments are then connected sequentially according to their starting acquisition time to generate a multi-step feedback state sequence.

[0117] Based on the multi-step feedback state sequence, the counterfactual baseline multi-step temporal difference method is adopted to calculate the multi-step benefit difference between the corresponding actions of each server node agent and each task agent in the continuous acquisition time, and generate the decision response value of the corresponding agent action.

[0118] The process of generating decision response values ​​is as follows: Based on continuous data collection time, read the computing resource utilization, memory resource utilization, network bandwidth utilization, computational task execution progress, computational task execution latency, and contention duration of each server node agent and each task agent under the corresponding actions from the multi-step feedback state sequence. Subtract the corresponding values ​​from the previous data collection time from the current data collection time's computing resource utilization, memory resource utilization, network bandwidth utilization, and computational task execution progress to obtain the resource utilization change and execution progress change. Subtract the corresponding values ​​from the previous data collection time's computational task execution latency and contention duration from the current data collection time to obtain the execution latency change and contention duration change. Then, process each change... Normalization is performed by adding the changes in resource utilization and execution progress, and subtracting the changes in execution latency and contention duration to obtain the actual time-series gains for each consecutive collection moment. The task reception amount in the current action of the server node agent is set to zero, while keeping the corresponding actions of other agents unchanged, and the counterfactual baseline time-series gains are obtained according to the same calculation process. The actual time-series gains are subtracted from the counterfactual baseline time-series gains to obtain the multi-step gains difference for each consecutive collection moment. Each multi-step gains difference is multiplied by a progressively decreasing time-series weight according to the collection moment from first to last, and the weighted multi-step gains differences are accumulated to generate the decision response value for the corresponding action of the server node agent or task agent.

[0119] The parameter update order of the corresponding agent is determined based on the decision response value of each agent's action, and the parameters of the improved COMAE collaborative model are updated asynchronously to form a closed-loop optimized server computing power allocation result.

[0120] The process of forming the server computing power allocation result is as follows: Read the decision response values ​​of the corresponding actions of each server node agent and each task agent; arrange the corresponding agents according to the absolute value of the decision response values ​​from largest to smallest to determine the parameter update order; input the multi-step feedback state sequence and the decision response values ​​of the corresponding agent actions into the improved COMAE collaborative model in sequence according to the parameter update order; calculate the update amount of the corresponding agent model parameters; and complete the update of the corresponding agent model parameters while keeping the parameters of other agent models unchanged; after each agent model parameter update is completed, write the updated model parameters into the improved COMAE collaborative model and continue to execute the next agent model parameter update until all agent model parameters are updated; input the multi-agent interaction results into the improved COMAE collaborative model that has completed asynchronous parameter updates for policy reasoning calculation, generate the updated server computing power allocation policy matrix, and execute the computing task allocation, computing resource scheduling, and computing task distribution according to the updated server computing power allocation policy matrix to form a closed-loop optimized server computing power allocation result.

[0121] Example 1: A server computing power allocation system based on multi-agent collaboration was deployed in a hybrid computing server cluster of an internet business platform. The server cluster includes 24 server nodes, of which 12 nodes are configured with 32-core processors and 128GB of memory, 8 nodes are configured with 64-core processors, 256GB of memory, and a graphics processor, and 4 nodes are configured with 48-core processors and high-speed storage devices. The server cluster simultaneously runs online request processing tasks, batch data analysis tasks, model training tasks, and report generation tasks. During the test, the server cluster received an average of approximately 860 computing tasks per minute, with a peak of approximately 1350 computing tasks per minute. Significant differences were observed in the computing power requirements, memory requirements, network bandwidth requirements, estimated execution time, and task deadlines for different computing tasks.

[0122] Before this invention, server clusters used a minimum load allocation method based on current processor utilization, prioritizing the allocation of newly arriving computing tasks to the server node with the lowest current processor utilization. This method only considered processor utilization at the moment of task allocation, without comprehensively considering server node memory usage, network bandwidth usage, task queue length, load change trends, or the degree of resource overlap between computing tasks. When model training tasks and online request processing tasks increased simultaneously, some server nodes equipped with graphics processing units (GPUs) were continuously assigned multiple high-computing-demand tasks, causing server node processor utilization to consistently exceed 90%, leading to contention for memory resources and network bandwidth; while the processor utilization of some ordinary server nodes was less than 45%, resulting in uneven load distribution across the server cluster. Simultaneously, computing tasks frequently migrated between multiple server nodes, increasing the average execution latency of online request processing tasks, and causing some computing tasks with execution deadlines to fail to complete on time.

[0123] Data is collected at 5-second intervals, including processor utilization, graphics processor utilization, memory usage, storage read / write speed, network bandwidth usage, task queue length, node response latency, and node fault status for each server node. For each computational task, data is also collected, including task type, computing power requirements, memory requirements, network bandwidth requirements, estimated execution time, task priority, task deadline, and task dependencies. The collected data undergoes missing value completion, outlier correction, normalization, and structuring to generate server node status information and computational task requirement information.

[0124] The system extracts resource reserves, load change trends, and task carrying capacity based on server node status information, and constructs a set of server node intelligent agents. It also extracts resource demand intensity, execution urgency, and resource overlap based on computation task demand information, and constructs a set of task intelligent agents. Server node intelligent agents represent the current resource status and task carrying capacity of each server node, while task intelligent agents represent the resource demand status and execution urgency of each computation task.

[0125] The system reads records of collaborative computing tasks performed by each server node within the past 30 days, calculates the historical collaboration frequency between server node agents, and calculates resource competition coefficients based on the overlap in computing resource, memory resource, and network bandwidth requirements of different computing tasks. The historical collaboration frequency between server nodes and the resource competition coefficient between computing tasks are fused to form a historical affinity matrix. A higher historical affinity is assigned to server node and computing task combinations with high historical collaboration frequency and low resource competition; a lower historical affinity is assigned to combinations with low historical collaboration frequency or high resource competition. The initial node state vector and initial task requirement vector are bidirectionally fused using the historical affinity matrix to generate node state vectors and task requirement vectors.

[0126] Node state vectors and task requirement vectors are written into the corresponding server node agents and task agents. The system establishes interactive connections based on the historical affinity matrix and generates asynchronous polling sequences according to the load variation of server nodes and the execution urgency of computational tasks. Server nodes with significant load variations and computational tasks with short execution timeframes are given priority in information broadcasting. After being filtered and aggregated based on historical affinity, the broadcast information forms multi-agent interaction results, reducing the interference of information with low relevance to the current computational task on computing power allocation.

[0127] The improved COMAE collaborative model inputs the results of multi-agent interactions. This improved model performs time-stamping on the interaction state vectors at different generation and arrival times, separates the local utility components of each server node agent and the task agent, and determines the contribution of each agent's actions to the overall decision through action surrogate methods. Subsequently, the allocation results are boundary-corrected based on the server node's computing power resources, memory resources, network bandwidth, and computation task execution time limits, generating a server computing power allocation strategy matrix.

[0128] During a peak scheduling period, the system simultaneously received 320 online request processing tasks, 86 data analysis tasks, and 18 model training tasks. The server computing power allocation strategy matrix prioritized assigning online request processing tasks with higher execution urgency and shorter expected execution time to server nodes with lower node response latency. Model training tasks were allocated to server nodes with larger GPU resource reserves, and data analysis tasks with high resource overlap were distributed across different server nodes. The system determined the corresponding server node and computing power allocation amount for each computing task based on allocation weights and computing power resource allocation ratios, generated computing task issuance instructions, and sent them to the corresponding server nodes for execution.

[0129] During the execution of computational tasks, the system continuously collects data on computing resource utilization, memory resource utilization, network bandwidth utilization, computational task execution progress, computational task execution latency, and resource contention conflict records, forming a task execution feedback sequence. Based on this feedback sequence, the system calculates the decision response values ​​for the corresponding actions of the server node agents and task agents, determines the parameter update order according to these decision response values, and asynchronously updates the parameters of the improved COMAE collaborative model. This ensures that the subsequent server computing power allocation strategy is continuously adjusted based on the actual execution results.

[0130] To verify the technical effectiveness of this invention, the existing minimum load allocation method was compared with this invention under the same server configuration, the same set of computing tasks, and the same test period. The test lasted for 7 days, with 4 hours of continuous operation during peak business hours each day, accumulating approximately 2.14 million computing tasks processed. The test results are shown in Table 1 below.

[0131] Table 1 Comparison of Server Computing Power Allocation System Performance

[0132] Average processor utilization of server nodes 61.8% 73.6% An increase of 11.8 percentage points Server node load dispersion factor 0.31 0.17 Reduced by 45.2% Average computation task execution latency 2.84 seconds 2.19 seconds Decreased by 22.9% Task deadline fulfillment rate 91.7% 97.2% Increased by 5.5 percentage points Number of resource contention conflicts per hour 146 times 83 times Reduced by 43.2% Number of migrations per thousand tasks 38 times 21 times Reduced by 44.7% Average utilization of graphics processor 68.4% 81.3% An increase of 12.9 percentage points Average generation time of computing power allocation strategy 186 milliseconds 142 milliseconds Decreased by 23.7% Peak-hour task throughput 1286 items / minute 1498 items / minute Increased by 16.5% Calculate the abnormal interruption rate of the task 2.6% 1.4% Reduced by 46.2%

[0133] As shown in Table 1, after the implementation of this invention, the average processor utilization rate of server nodes increased from 61.8% to 73.6%, and the average graphics processor utilization rate increased from 68.4% to 81.3%, indicating that this invention can improve the utilization of computing resources based on server node status information and computing task requirements. The server node load dispersion coefficient decreased from 0.31 to 0.17, indicating that the load difference between different server nodes was significantly reduced, avoiding the problem of some server nodes continuously operating at high loads while other server nodes had idle resources.

[0134] This invention reduces the average execution latency of computing tasks from 2.84 seconds to 2.19 seconds and increases the task deadline fulfillment rate from 91.7% to 97.2%. The main reason for this is that the system matches computing tasks with server nodes based on execution urgency, historical affinity, and resource contention coefficients, allowing computing tasks with shorter execution deadlines to obtain corresponding computing resources first. Simultaneously, the number of resource contention conflicts per hour decreases from 146 to 83, and the number of migrations per thousand tasks decreases from 38 to 21. This indicates that through collaborative interaction between server node agents and task agents, the concentration of highly overlapping computing tasks on the same server node can be reduced.

[0135] The average generation time of the computing power allocation strategy in this invention is reduced from 186 milliseconds to 142 milliseconds, and the peak-hour task throughput is increased from 1286 tasks per minute to 1498 tasks per minute. Asynchronous information polling and broadcasting avoids synchronous waiting for all server nodes, and can prioritize server nodes with significant load changes and computational tasks with high execution urgency. After asynchronously updating the parameters of the improved COMAE collaborative model in conjunction with execution feedback, the abnormal interruption rate of computational tasks is reduced from 2.6% to 1.4%, indicating that this invention can continuously adjust the server computing power allocation strategy according to the server cluster operating status and computational task execution results, and has good dynamic adaptability and operational stability.

[0136] The above are merely preferred embodiments of the present invention, but the scope of protection of the present invention is not limited thereto. Any equivalent substitutions or modifications made by those skilled in the art within the scope of the technology disclosed in the present invention, based on the technical solution and inventive concept of the present invention, should be covered within the scope of protection of the present invention.

Claims

1. A server computing power allocation system based on multi-agent collaboration, characterized in that, include: The data processing module is used to preprocess running status data and task attribute data, and generate server node status information and computing task requirement information. The agent construction module is used to construct a set of server node agents based on server node status information and a set of task agents based on computing task requirement information. The feature fusion module is used to fuse and embed the historical collaboration frequency between nodes and the resource competition coefficient between tasks based on the server node intelligent agent set and the task intelligent agent set, to construct a historical affinity matrix and generate node state vector and task demand vector. The interaction processing module is used to construct a multi-agent interaction environment based on node state vectors and task requirement vectors, and to perform asynchronous information polling and broadcasting to generate multi-agent interaction results. The strategy generation module is used to input the multi-agent interaction results into the improved COMAE collaborative model for strategy reasoning and calculation, and generate the server computing power allocation strategy matrix. The scheduling and execution module is used to allocate computing tasks and perform elastic scheduling of computing resources according to the server computing power allocation strategy matrix, and to distribute and control the execution of computing tasks. The feedback optimization module is used to collect real-time performance feedback data and resource contention conflict records during the execution of computing tasks. It uses counterfactual baseline multi-step temporal difference to calculate the decision response values ​​of each agent's actions and asynchronously updates the parameters of the improved COMAE collaborative model to form the server computing power allocation results.

2. The server computing power allocation system based on multi-agent collaboration according to claim 1, characterized in that, According to a unified sampling period, processor utilization, graphics processor utilization, memory usage, storage read / write speed, network bandwidth usage, task queue length, node response latency, and node fault status of each server node are collected to form runtime status data. The task type, computing power requirement, memory requirement, network bandwidth requirement, estimated execution time, task priority, task deadline, and task dependencies of each computing task are obtained to form task attribute data. Missing value completion, outlier correction, and normalization processing are performed on the runtime status data. Field parsing, type conversion, priority encoding, and task dependency marking are performed on the task attribute data to generate server node status information and computing task requirement information.

3. The server computing power allocation system based on multi-agent collaboration according to claim 1, characterized in that, The intelligent agent construction module includes: Based on the server node status information, extract the resource reserves, load change trends and task carrying capacity of each server node, and encode the collaborative roles to generate a set of server node status features. Each server node is used as a server node agent. The corresponding server node state features in the server node state feature set are written into the corresponding server node agent to generate a server node agent set. Based on the computing task requirement information, the resource requirement intensity, execution urgency and resource overlap of each computing task are extracted, and the competitive roles are encoded to generate a set of computing task requirement features. Each computing task is used as a task agent. The corresponding computing task requirement features in the set of computing task requirement features are written into the corresponding task agent to generate a set of task agents.

4. A server computing power allocation system based on multi-agent collaboration according to claim 1, characterized in that, The feature fusion module includes: The server node state features in the server node agent set and the computational task requirement features in the task agent set are vectorized to generate initial node state vectors and initial task requirement vectors. The historical collaboration frequency is calculated based on the computing task collaboration records of each server node intelligent agent pair, and the resource competition coefficient is calculated based on the degree of overlap in computing resource requirements of each task intelligent agent pair. Based on the historical collaboration frequency and resource competition coefficient, the historical affinity between each server node agent and each task agent is determined, a historical affinity matrix is ​​constructed, and the historical affinity matrix is ​​normalized to generate task fusion weights and node fusion weights. Based on the task fusion weight, the initial task requirement vector is injected into the initial node state vector in a targeted manner, and residual coupling is performed to generate the node state vector. Based on the node fusion weight, the initial node state vector is injected into the initial task requirement vector in a targeted manner, and residual coupling is performed to generate the task requirement vector.

5. A server computing power allocation system based on multi-agent collaboration according to claim 1, characterized in that, The interaction processing module includes: Write the node state vector into the corresponding server node agent, write the task requirement vector into the corresponding task agent, and establish the interaction connection between the server node agent and the task agent based on the historical affinity matrix to build a multi-agent interaction environment. Based on the load change trend of each server node agent and the execution urgency of each task agent, the information polling priority is determined, and an asynchronous polling sequence is generated according to the information polling priority. Read the node state vector of each server node agent and the task requirement vector of each task agent in sequence according to the asynchronous polling sequence, and generate agent broadcast information. Send agent broadcast information along the interaction connection, filter and aggregate the agent broadcast information, and generate an interaction state vector; The interaction state vectors are summarized according to the correspondence between the server node agents and the task agents to generate multi-agent interaction results.

6. A server computing power allocation system based on multi-agent collaboration according to claim 1, characterized in that, The strategy generation module includes: The results of multi-agent interaction are input into the improved COMAE collaborative model for policy reasoning calculation. The improved COMAE collaborative model includes a time-stamped trajectory calibration module, a group utility decoupling module, an action surrogate evaluation module, and a boundary constraint projection module. The improvement of the improved COMAE collaborative model is as follows: the traditional COMAE collaborative model obtains the overall decision benefit corresponding to the joint action through centralized value evaluation to determine the contribution of each agent's action to the overall decision. The improved COMAE collaborative model performs time-stamped calibration based on the generation time, arrival time, and state change amplitude of the interaction state vector. It separates and reconstructs the local utility components through the mirror barrier penetration mechanism, evaluates the independent contribution of each agent's action through the action surrogate method, and performs boundary correction on the surrogate contribution value in combination with computing power resources, memory resources, network bandwidth, and execution time limit to generate a server computing power allocation strategy matrix that matches the server cluster's operating status and computing task requirements. In the time-stamped trajectory calibration module, based on the generation time, arrival time and state change amplitude between adjacent interactive state vectors in the multi-agent interaction results, a time-series offset ridge is constructed, and segmented traction calibration and missing state backfilling are performed on each interactive state vector according to the time-series offset ridge to generate a time-stamped calibration interaction sequence. In the group utility decoupling module, the local utility components corresponding to the server node agent and the task agent are separated according to the time-stamped calibration interaction sequence. A mirror barrier penetration mechanism is introduced. The local utility components are reverse-mapped with the group utility center as the mirror reference to generate mirror utility components. A utility barrier is constructed according to the utility difference between the local utility components and the mirror utility components. The utility penetration direction and utility penetration intensity are determined according to the continuous change of the utility barrier. The local utility components after penetration are rearranged according to the utility penetration intensity to generate a barrier utility representation. In the action surrogate evaluation module, surrogate actions are generated for each server node agent and task agent based on the barrier utility representation. The current action of the corresponding agent is replaced by the surrogate action, and the surrogate contribution value is generated based on the difference of local utility components before and after the action replacement. In the boundary constraint projection module, a boundary constraint interval is constructed based on the computing power resources, memory resources, network bandwidth, and execution time limits of each computing task of each server node. The substitute contribution value located outside the boundary constraint interval is bounced back along the corresponding boundary direction and alternately corrected to generate a boundary correction contribution value. The allocation weight and computing power resource allocation ratio between each computing task and each server node are determined based on the boundary correction contribution value. The computing power allocation strategy matrix is ​​generated by arranging the computing task identifier and server node identifier in a matrix.

7. A server computing power allocation system based on multi-agent collaboration according to claim 1, characterized in that, The scheduling execution module includes: Read the allocation weights and computing resource allocation ratios from the server computing power allocation strategy matrix to determine the scheduling priority of computing tasks; The computing tasks are arranged according to their scheduling priority, and the corresponding server nodes are determined based on the allocation weight of each computing task to generate the computing task allocation results. Based on the computing task allocation results, determine the computing resource scheduling amount corresponding to each computing task and generate computing resource scheduling results. Based on the computing resource scheduling results, a computing task issuance instruction is generated and sent to the corresponding server node for execution control.

8. A server computing power allocation system based on multi-agent collaboration according to claim 1, characterized in that, The feedback optimization module includes: Collect real-time performance feedback data and resource contention conflict records during the execution of each computing task, and generate a task execution feedback sequence; The task execution feedback sequence is continuously segmented according to the collection time to generate a multi-step feedback state sequence; Based on the multi-step feedback state sequence, the counterfactual baseline multi-step temporal difference method is adopted to calculate the multi-step benefit difference between the corresponding actions of each server node agent and each task agent in the continuous acquisition time, and generate the decision response value of the corresponding agent action. The parameter update order of the corresponding agent is determined based on the decision response value of each agent's action. The parameters of the improved COMAE collaborative model are updated asynchronously to form a closed-loop optimized server computing power allocation result.

Images