Resource affinity-based computing power scheduling method, apparatus and device, and medium

Abstract

The invention relates to a computing power scheduling method and device based on resource affinity, equipment and a medium, and the method comprises the following steps: collecting the load state data of each computing node through a computing power node monitoring module; then demand analysis is carried out on a task submitted by a user, a task resource demand vector is generated, affinity matching is carried out on the task resource demand vector and node load data, and a resource affinity matching value is obtained; then analyzing the dependency relationship between the nodes, calculating a resource dependency coefficient, and weighting the resource dependency coefficient with the affinity matching value to obtain a comprehensive affinity value; sorting the comprehensive affinity values in a descending order to form a node priority sequence; and finally, computing power mapping scheduling is carried out based on the sequence, and a final scheduling scheme is generated. According to the method, the resource matching degree and the node cooperation relation are comprehensively considered, the scheduling efficiency and the resource utilization rate are improved, and the technical problems that the resource utilization rate is low, task response delay is high and loads among the nodes are uneven due to a traditional scheduling method are solved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of resource affinity, in particular to a resource affinity-based computing power scheduling method, device, equipment and medium. BACKGROUND

[0002] With the increasing complexity and diversification of computing tasks, how to efficiently schedule tasks to suitable computing nodes has become a key challenge in the field of computing power scheduling. Traditional scheduling methods are mostly based on single resource indicators or static priorities, which are difficult to adapt to dynamic changing load environments and task requirements, resulting in low resource utilization, high task response delay and uneven load between nodes. The above technical solutions introduce resource affinity matching, node dependency analysis and comprehensive weighted sorting mechanism, aiming to solve the technical problems of low resource matching degree, low scheduling efficiency and unstable task execution performance of existing computing power scheduling methods in dynamic load environment. SUMMARY

[0003] The main purpose of the present application is to provide a resource affinity-based computing power scheduling method, which solves the technical problems of low resource utilization, high task response delay and uneven load between nodes caused by traditional scheduling methods based on single resource indicators or static priorities, which are difficult to adapt to dynamic changing load environments and task requirements.

[0004] To achieve the above purpose, the present application provides a resource affinity-based computing power scheduling method, comprising the following steps: Collecting the load state data of each computing node in the target device through the computing power node monitoring module; Analyzing the demand of the computing task submitted by the target user to obtain a task resource demand vector, and matching the task resource demand vector with the node load state data to obtain a resource affinity matching value; Analyzing the node dependency relationship based on the resource affinity matching value to obtain a resource dependency coefficient, and performing weighted calculation on the resource affinity matching value and the resource dependency coefficient to obtain a comprehensive affinity value; Sorting the comprehensive affinity value in descending order to obtain a node priority sequence, and performing computing power mapping scheduling on the task resource demand vector based on the node priority sequence to obtain a computing power scheduling scheme.

[0005] Further, the collecting of the load state data of each computing node in the target device through the computing power node monitoring module comprises: The computing node monitoring module periodically samples each computing node in the target device to obtain original load time series data, and performs outlier rejection processing on the original load time series data to obtain preprocessed load time series data. Based on the preprocessed load time series data, feature dimension extraction is performed to obtain multi-dimensional load features, and normalization conversion is performed on the multi-dimensional load features to obtain standardized load features. The standardized load features are analyzed for spatio-temporal correlation to obtain a node load correlation matrix, and the standardized load feature set and the node load correlation matrix are fused to obtain node load state data.

[0006] Further, the demand analysis of the computing task submitted by the target user obtains a task resource demand vector, including: The description text in the computing task submitted by the target user is parsed for syntax structure to extract a task attribute feature set, and the computing task is classified and encoded based on the task attribute feature set to obtain a task classification encoding vector. The task classification encoding vector is matched and searched in a preset resource mapping rule library to obtain a task resource demand vector.

[0007] Further, the affinity matching of the task resource demand vector based on the node load state data obtains a resource affinity matching value, including: The node load state data is dimensionally extracted to obtain a node dimension vector, and the dimensions of the task resource demand vector and the node dimension vector are aligned to obtain a same dimension feature vector group. The node load state data is vectorized to obtain a node load state vector, the cosine similarity between the task resource demand vector and the node load state vector is calculated based on the same dimension feature vector group to obtain a basic matching coefficient, and the absolute value of the difference between the corresponding dimensions in the same dimension feature vector group is calculated to obtain a dimension difference value set. The dimension difference value set is normalized to obtain a normalized difference value set, and the normalized difference value set and a preset dimension weight are weighted and summed to obtain a comprehensive difference coefficient. The resource affinity matching value is obtained based on the numerical fusion of the basic matching coefficient and the comprehensive difference coefficient.

[0008] Further, the resource affinity matching value is analyzed for node dependency to obtain a resource dependency coefficient, including: Correlation relationship mining is performed on the computing nodes corresponding to the resource affinity matching value, a node correlation graph is constructed, and weight values are assigned to edges in the node correlation graph to obtain a weighted node correlation graph; Based on the weighted node correlation graph, path traversal is performed, the shortest dependency paths between the computing nodes are extracted, and the weights of the shortest dependency paths are accumulated to obtain a path dependency weight value; The path dependency weight value is normalized to obtain a standardized path weight, and the standardized path weight is arranged in a matrix according to node pairs to obtain a dependency weight matrix; Based on the dependency weight matrix and the resource affinity matching value, a row-by-row weighted average calculation is performed to obtain a resource dependency coefficient of each computing node.

[0009] Further, the path traversal based on the weighted node correlation graph and the extraction of the shortest dependency paths between the computing nodes include: Each computing node in the weighted node correlation graph is initialized for path recording to obtain an initial path recording table; In the initial path recording table, an intermediate node is selected in order of node degree from high to low, the path length from the starting node to other nodes through the intermediate node is compared and updated, and an updated path recording table is obtained; The path length in the updated path recording table is filtered for the minimum value to determine the minimum path length of each node pair, and the path node sequence corresponding to the minimum path length is extracted to obtain the shortest dependency paths between the computing nodes.

[0010] Further, the power mapping scheduling of the task resource demand vector based on the node priority sequence to obtain the power scheduling scheme includes: The node load state data is sorted according to the node priority sequence to obtain a sorted load state vector, and the sorted load state vector and the task resource demand vector are difference calculated to obtain a node resource gap value, and the node resource gap value is judged to be positive or negative to filter out candidate nodes with a non-positive resource gap value; The resource satisfaction degree is calculated based on the candidate nodes and the task resource demand vector; Task fragmentation adaptation analysis is performed on the candidate nodes with a resource satisfaction degree reaching a preset threshold to obtain a fragmentation adaptation scheme, and the fragmented tasks in the fragmentation adaptation scheme are bound and mapped to the candidate nodes to obtain a preliminary scheduling mapping table; The load balancing degree of the nodes in the preliminary scheduling mapping table is calculated to obtain a load balancing coefficient, and the preliminary scheduling mapping table is adjusted and optimized based on the load balancing coefficient to obtain the power scheduling scheme.

[0011] The application also provides a resource affinity computing power scheduling device, comprising: The acquisition module is configured to acquire the load state data of each computing node in the target device through the computing node monitoring module. The analysis module is configured to analyze the node dependency relationship based on the resource affinity matching value, obtain a resource dependency coefficient, and perform weighted calculation on the resource affinity matching value and the resource dependency coefficient to obtain a comprehensive affinity value. The analysis module is configured to analyze the node dependency relationship based on the resource affinity matching value, obtain a resource dependency coefficient, and perform weighted calculation on the resource affinity matching value and the resource dependency coefficient to obtain a comprehensive affinity value. The sorting module is configured to sort the comprehensive affinity value in descending order to obtain a node priority sequence, and perform computing power mapping scheduling on the task resource demand vector based on the node priority sequence to obtain a computing power scheduling scheme.

[0012] The application also provides a computer device comprising a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to realize the steps of the method according to any one of the above.

[0013] The application also provides a computer readable storage medium having a computer program stored thereon, wherein the computer program is executed by a processor to realize the steps of the method according to any one of the above.

[0014] The application provides a resource affinity computing power scheduling method, comprising the following steps: acquiring the load state data of each computing node in the target device through the computing node monitoring module; analyzing the demand of the computing task submitted by the target user to obtain a task resource demand vector, and performing affinity matching on the task resource demand vector based on the node load state data to obtain a resource affinity matching value; analyzing the node dependency relationship based on the resource affinity matching value to obtain a resource dependency coefficient, and performing weighted calculation on the resource affinity matching value and the resource dependency coefficient to obtain a comprehensive affinity value; sorting the comprehensive affinity value in descending order to obtain a node priority sequence, and performing computing power mapping scheduling on the task resource demand vector based on the node priority sequence to obtain a computing power scheduling scheme. BRIEF DESCRIPTION OF DRAWINGS

[0015] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0016] Figure 1 This is a schematic diagram of the steps of a resource affinity-based computing power scheduling method in one embodiment of the present invention; Figure 2 This is a structural block diagram of a resource affinity-based computing power scheduling device according to an embodiment of the present invention; Figure 3 This is a schematic block diagram of the structure of a computer device according to an embodiment of the present invention.

[0017] The objectives, features, and advantages of this invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0018] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention.

[0019] like Figure 1 As shown, Figure 1 This invention provides a resource affinity-based computing power scheduling method, comprising the following steps: Step S1: The load status of each computing node in the target device is collected through the computing node monitoring module to obtain node load status data. Step S2: Analyze the computing tasks submitted by the target user to obtain a task resource requirement vector, and perform affinity matching on the task resource requirement vector based on the node load status data to obtain a resource affinity matching value. Step S3: Analyze node dependency relationships based on the resource affinity matching value to obtain the resource dependency coefficient, and perform a weighted calculation on the resource affinity matching value and the resource dependency coefficient to obtain a comprehensive affinity value; Step S4: Sort the comprehensive affinity values ​​in descending order to obtain a node priority sequence, and perform computing power mapping and scheduling on the task resource requirement vector based on the node priority sequence to obtain a computing power scheduling scheme.

[0020] Specifically, in the present scheme, a resource affinity-based computing power scheduling method is proposed, aiming to achieve efficient matching between tasks and computing nodes through systematic resource evaluation and scheduling mechanism, thereby improving the resource utilization and task execution efficiency of the overall computing power system. First, in step S1, the system continuously collects real-time load state data of each computing node through the computing power node monitoring module deployed in the target device. This module can obtain various resource indicators including CPU usage, memory occupancy, network bandwidth, I / O throughput, etc., forming a comprehensive perception of the current resource availability of the node. For example, in the computing power scheduling scenario of a data center, if a node is running multiple high-concurrency tasks, its CPU and memory resources may be close to saturation, while another node is in a low-load state. Through the computing power node monitoring module, real-time information can be obtained to provide basic data support for subsequent scheduling decisions. Next, in step S2, the system analyzes the resource requirements of the computing task submitted by the user, extracts various resource indicators required by the task, and constructs a task resource requirement vector. This vector may include the number of CPU cores, memory size, GPU resources, network bandwidth required by the task. Then, the system performs affinity matching calculation between the task resource requirement vector and the node load state data obtained in step S1 to evaluate the resource adaptation degree between the task and each computing node. For example, if a task has high demand for GPU computing power, and a node has high-performance GPU resources and is currently under low load, the resource affinity matching value between the node and the task will be higher; otherwise, if the GPU resources of a node are fully loaded, its matching value will be lower. This affinity matching mechanism enables the scheduling system to establish a more accurate resource matching relationship between tasks and nodes. Then, in step S3, the system further analyzes the dependency relationship between nodes based on the resource affinity matching value obtained in step S2 to obtain the resource dependency coefficient. In the actual computing power environment, there may be resource dependency relationships between multiple computing nodes, such as frequent communication or shared storage resources between some nodes. If this dependency relationship is ignored, it may lead to increased communication delay, intensified resource contention, etc. after task scheduling. Therefore, the system identifies the resource dependency between nodes by analyzing the resource affinity trend between nodes and calculates the resource dependency coefficient based on this. Then, the system performs weighted calculation on the resource dependency coefficient and the resource affinity matching value in step S2 to obtain the comprehensive affinity value. The significance of this step is to consider not only the resource matching degree between tasks and nodes, but also the coordination efficiency between nodes, thereby improving the rationality of overall scheduling and the stability of task execution. Finally, in step S4, the system sorts the comprehensive affinity values of all nodes in descending order to generate a node priority sequence. This priority sequence reflects the sorting of the adaptation degree of each node to the current task under the current system state.Based on this priority sequence, the system maps the task resource requirement vector to the most suitable node, forming the final computing power scheduling scheme. For example, in a large-scale parallel computing task, the system may allocate multiple subtasks to the computing node with the highest matching degree according to the node priority, ensuring that the task meets resource requirements while minimizing inter-node communication overhead and improving task execution efficiency. To further illustrate the practical application effect of this scheme, suppose a user submits a deep learning model training task in a cloud computing platform, which has high requirements for GPU resources, memory bandwidth, and network communication. At this time, the system first collects the load status data of each computing node through the computing power node monitoring module. It finds that node A has low GPU utilization, a lot of idle memory, and low network latency; while node B has sufficient GPU resources, its current memory is close to saturation; node C is under high load and has almost no available resources. Subsequently, the system performs requirement analysis on the task, constructs its resource requirement vector, including the requirement indicators for GPU computing power, memory capacity, and network bandwidth, and performs affinity matching calculation based on the node load status data, finding that node A has the highest resource affinity matching value, followed by node B, and node C has the lowest. Next, the system further analyzes the resource dependencies between nodes. For example, if there is a high-speed interconnection channel between node A and node D, suitable for frequent data exchange between tasks, while there is a communication bottleneck between node B and other nodes, then node A's resource dependency coefficient will be higher. The system calculates a weighted average affinity value based on the affinity matching value and the resource dependency coefficient to obtain a comprehensive affinity value. After sorting, node A remains at the top. Finally, the system schedules the deep learning task to be executed on node A according to the node priority sequence, thus achieving a scheduling decision with high resource matching and excellent communication efficiency.

[0021] In a specific embodiment, the step of collecting load status data of each computing node in the target device through the computing node monitoring module to obtain node load status data includes: The computing node monitoring module periodically samples each computing node in the target device to obtain raw load time series data, and performs outlier removal processing on the raw load time series data to obtain preprocessed load time series data. Based on the preprocessed load time series data, feature dimensions are extracted to obtain multi-dimensional load features, and the multi-dimensional load features are normalized to obtain standardized load features. Spatiotemporal correlation analysis is performed on the standardized load features to obtain the node load correlation matrix. The standardized load feature set and the node load correlation matrix are then fused to obtain node load status data.

[0022] Specifically, the system first periodically samples each computing node in the target device through the computing node monitoring module, such as collecting CPU usage, memory occupancy, GPU utilization, network bandwidth usage, and other resource indicators every second, to form raw load time series data. Taking a typical data center as an example, assume that a certain node records CPU usage every second for 30 consecutive seconds, resulting in a data sequence of [45%, 46%, 44%, 50%, 48%, 47%, 95%, 46%, 45%, 47%, …], where the value at the 7th second (95%) is significantly higher than other time points, which may be an abnormal value caused by a sudden surge in tasks or sampling error. To avoid such abnormal values interfering with subsequent analysis, the system performs outlier rejection processing on the raw load time series data, such as using the sliding window average method or the 3σ principle to remove data points that deviate from the normal range or replace them with the average of adjacent values, to obtain preprocessed load time series data, such as replacing the 95% at the 7th second in the above sequence with 46% to form a more stable and representative data sequence. Next, the system performs multi-dimensional feature extraction based on the preprocessed load time series data to more comprehensively characterize the load state of the computing node. These features may include: the current instantaneous resource usage, the average resource usage in the near future, the resource usage fluctuation amplitude (standard deviation), the resource usage trend (such as upward or downward trend), the resource usage peak, etc. For example, for the CPU usage preprocessed data of a certain node, the system can extract the current instantaneous value as 47%, the average value in the last 10 seconds as 46%, the standard deviation as 1.2%, the trend as stable, and the maximum value as 48%, etc. to form multi-dimensional load features. To facilitate subsequent comparison and calculation, the system normalizes these multi-dimensional load features to fall within a unified numerical range (such as between 0 and 1), to obtain standardized load features. For example, if the CPU usage of a certain node is normalized to 0.47, the memory usage to 0.35, and the network bandwidth usage to 0.28, these values can be used for subsequent multi-node comparison and analysis. On this basis, the system further analyzes the spatio-temporal correlation of the standardized load features to identify the load change correlation between nodes and construct a node load correlation matrix. For example, in a data center consisting of 10 computing nodes, the system can analyze the change trends of resource usage between nodes 1 and 2, and find that their resource usage at multiple time points presents a high degree of synchronization (such as a correlation coefficient of 0.85), while the resource usage between nodes 3 and 4 presents a negative correlation (such as a correlation coefficient of -0.6), indicating that they may have a resource complementary relationship. Through this analysis, the system can construct a 10x10 node load correlation matrix, where each element represents the resource usage correlation strength and direction between two nodes.Finally, the system fuses the standardized load feature set with the node load correlation matrix to obtain complete node load state data. This fusion process can be understood as combining the load state of a single node with its role in the global network, thereby forming a three-dimensional description of the node load state. For example, in the above 10-node system, the standardized load features of node 1 indicate that its current CPU load is 0.47, memory load is 0.35, and network load is 0.28, while it shows a high correlation with node 2 and a weak correlation with node 5 in the node load correlation matrix. After fusing this information, the system can more accurately determine whether node 1 is suitable as an execution node for a certain task, especially when the task requires collaborative computation with other nodes. Through the above steps, the system achieves a comprehensive perception and modeling of the load state of each computing node in the target device, providing a solid data foundation for subsequent resource affinity matching, dependency analysis, and scheduling decisions. Taking a deep learning training task as an example, this task has high requirements for GPU resources and memory bandwidth, and requires multiple nodes to collaborate. After the system collects and processes the load state data of each node through the above process, it can identify which nodes have sufficient GPU resources, which nodes have high communication efficiency between them, and which nodes have low current load, thereby providing a scientific basis for task scheduling. For example, the system finds that node A has a current GPU load of 0.3 and a memory load of 0.25, and the resource usage correlation coefficient between it and node B is 0.8, indicating that they have good collaboration. Therefore, the system may prefer to assign the task to node A and schedule its subtasks to node B to achieve dual optimization of resource utilization efficiency and task execution efficiency.

[0023] In specific embodiments, the demand analysis of the computing task submitted by the target user to obtain a task resource demand vector includes: performing syntax structure analysis on the description text in the computing task submitted by the target user, extracting a task attribute feature set, and performing task classification coding on the computing task based on the task attribute feature set to obtain a task classification coding vector; performing matching retrieval on the task classification coding vector in a pre-set resource mapping rule library to obtain a task resource demand vector.

[0024] Specifically, the demand analysis of the computing task submitted by the target user obtains the task resource demand vector, which is the key pre-step to realize accurate computing power scheduling. The core is to convert the unstructured or semi-structured task description submitted by the user into quantifiable and system-identifiable resource demand information. This process first parses the syntax structure of the description text in the computing task to extract the key attribute feature set of the task. These attribute features may include task type (such as image processing, machine learning training, data encryption), expected execution time, input data size, required software environment, whether specific hardware acceleration (such as GPU, FPGA) is needed, etc. Syntax structure parsing usually relies on natural language processing techniques, such as dependency syntax analysis, named entity recognition, etc., to accurately identify the functional and constraint semantic information contained in the task description. For example, in an edge computing supported intelligent transportation system, when a user submits a request for a "real-time high-definition video stream license plate recognition task", the system will parse the syntax of this text and identify that "real-time" indicates low latency requirements, "high-definition video stream" means high bandwidth and large memory requirements, and "license plate recognition" is associated with image processing and deep learning model inference, thereby forming a task attribute feature set containing these dimensions. On this basis, the system further classifies and encodes the computing task based on the task attribute feature set to generate a task classification encoding vector. The encoding process usually uses a pre-trained classification model or a rule engine to map the extracted task attributes to a pre-defined task category space, such as classifying "license plate recognition" into the "computer vision-target detection" category and assigning a corresponding encoding value, finally forming a numerical task classification encoding vector. This vector not only retains the semantic category information of the task, but also provides a structured input for subsequent resource mapping. Then, the system uses the task classification encoding vector to perform matching retrieval in the pre-set resource mapping rule library, which stores the mapping relationship between various task classification encodings and their typical resource consumption patterns, such as "computer vision-target detection" tasks usually requiring at least 4-core CPU, 16GB memory and a medium computing power GPU. Through matching retrieval, the system can automatically obtain the most matched resource configuration template for the current task, i.e. the task resource demand vector, which specifically quantifies the required CPU core number, memory capacity, GPU computing power, storage I / O and network bandwidth, etc.Therefore, when the intelligent traffic system receives the "real-time high-definition video stream license plate recognition task", relevant features are obtained through syntax analysis and attribute extraction, and a corresponding task classification code vector is generated through classification coding. The system finds a matching entry in the resource mapping rule library and finally outputs a specific task resource demand vector, such as [CPU: 6 cores, memory: 24 GB, GPU: 1 block (computing power ≥ 10 TFLOPS), network bandwidth: ≥ 100 Mbps], which provides accurate input basis for subsequent similarity matching with node resource features and calculation of resource affinity initial value, thereby ensuring that the scheduling decision not only meets the actual needs of the task, but also fully utilizes the underlying computing power resources.

[0025] In specific embodiments, the affinity matching of the task resource demand vector based on the node load state data obtains a resource affinity matching value, including: The node load state data is dimensionally extracted to obtain a node dimension vector, and the dimensions of the task resource demand vector are aligned with the node dimension vector to obtain a same dimension feature vector group; The node load state data is vectorized to obtain a node load state vector, the cosine similarity of the task resource demand vector and the node load state vector is calculated based on the same dimension feature vector group to obtain a basic matching coefficient, and the numerical values in the corresponding dimensions of the same dimension feature vector group are calculated by absolute difference to obtain a dimension difference value set; The dimension difference value set is normalized to obtain a normalized difference value set, and the normalized difference value set is weighted and summed with a preset dimension weight to obtain a comprehensive difference coefficient; The resource affinity matching value is obtained based on the numerical fusion of the basic matching coefficient and the comprehensive difference coefficient; wherein the value range of the resource affinity matching value is [0, 1], and the larger the value, the higher the resource affinity of the computing node and the computing task.

[0026] Specifically, after completing the node load state data collection and task resource demand vector generation, the system first extracts the dimensions of the node load state data, extracts the resource dimensions corresponding to the task resource demand vector, such as CPU usage, GPU computing power, memory occupancy, network bandwidth, I / O throughput, etc., to form a node dimension vector. For example, in the scheduling scenario of a data center, if the task resource demand vector contains 5 dimensions: GPU computing power (TFLOPS), memory capacity (GB), CPU utilization (%), network bandwidth (Gbps), and I / O throughput (MB / s), the system will extract the corresponding dimensions from the node load state data to form a node dimension vector, such as [18, 28, 45, 0.9, 480], indicating that the current GPU computing power of the node is 18 TFLOPS, the memory remaining is 28 GB, the CPU usage is 45%, the network bandwidth is 0.9 Gbps, and the I / O throughput is 480 MB / s. To ensure consistency of resource dimensions between tasks and nodes, the system performs dimension alignment processing on the task resource demand vector and the node dimension vector to form a same-dimension feature vector group, such as the task resource demand vector [20, 32, 50, 1.2, 600], and the aligned same-dimension feature vector group is a one-to-one correspondence combination of the task resource demand vector and the node dimension vector. On this basis, the system further vectorizes the node dimension vector as the node load state vector, and calculates the cosine similarity between the task resource demand vector and the node load state vector based on the same-dimension feature vector group, thereby obtaining the basic matching coefficient. Cosine similarity is an index that measures the degree of similarity between two vectors in direction, with a value range of [-1, 1], but in this system it is adjusted to the range [0, 1] through normalization processing, and the larger the value, the closer the direction of the two vectors, i.e. the higher the matching degree of task demand and node resource state. For example, if the task resource demand vector is [20, 32, 50, 1.2, 600] and the node load state vector is [18, 28, 45, 0.9, 480], the cosine similarity between them may be 0.93, indicating that the direction matching degree of resource demand and availability is high, and thus the basic matching coefficient is 0.93. Next, the system further calculates the absolute value of the difference between the corresponding dimensions in the same-dimension feature vector group to obtain a dimension difference value set. For example, the difference in GPU computing power between the task resource demand vector and the node dimension vector is |20-18|=2, the difference in memory capacity is |32-28|=4, the difference in CPU utilization is |50-45|=5, the difference in network bandwidth is |1.2-0.9|=0.3, and the difference in I / O throughput is |600-480|=120, thereby obtaining the dimension difference value set [2, 4, 5, 0.3, 120].For subsequent comparison and fusion, the system normalizes the dimension difference value set to the range of [0, 1], forming a normalized difference value set. For example, assuming the maximum GPU dimension difference is 10 and the current difference is 2, the normalized value is 0.2; the maximum memory dimension difference is 50 and the current difference is 4, the normalized value is 0.08, and so on. The final normalized difference value set is, for example, [0.2, 0.08, 0.1, 0.3, 0.24]. Then, the system weights and sums the normalized difference value set and the preset dimension weight to obtain the comprehensive difference coefficient. For example, if the system presets the dimension weight as [0.4, 0.3, 0.1, 0.1, 0.1] corresponding to the GPU, memory, CPU, network, and I / O five dimensions, the weighted comprehensive difference coefficient is: 0.2x0.4 + 0.08x0.3 + 0.1x0.1 + 0.3x0.1 + 0.24x0.1 = 0.08 + 0.024 + 0.01 + 0.03 + 0.024 = 0.168. This coefficient reflects the overall difference between the task resource demand and the node resource state in each dimension. The larger the value, the greater the difference and the lower the matching degree. Finally, the system fuses the basic matching coefficient and the comprehensive difference coefficient to generate the resource affinity matching value. This fusion process usually uses weighted average or other nonlinear combination methods, so that the final resource affinity matching value falls within the [0, 1] interval, where the larger the value, the higher the resource affinity between the computing node and the computing task. For example, if the basic matching coefficient is 0.93 and the comprehensive difference coefficient is 0.168, the system uses the fusion formula: resource affinity matching value = basic matching coefficient x (1 - comprehensive difference coefficient), and the calculation result is 0.93 x (1 - 0.168) = 0.93 x 0.832 ≈ 0.774. This value is the resource affinity matching value between the task and the node, which is used for subsequent node priority sorting and scheduling decisions. To further illustrate the practical application effect of this mechanism, assume that in a deep learning training platform, a user submits an image classification training task with a task resource demand vector of [25, 40, 60, 1.5, 700], representing the demand for GPU power, memory, CPU, network bandwidth, and I / O throughput. After obtaining the node load state data from node A, the system extracts the node dimension vector as [22, 35, 55, 1.2, 600] and performs dimension alignment processing.The base matching coefficient is calculated as 0.91, the dimension difference value set is [3, 5, 5, 0.3, 100], the normalized difference value set is [0.3, 0.125, 0.083, 0.2, 0.143], and the comprehensive difference coefficient is calculated as 0.235 in combination with the preset weight [0.4, 0.3, 0.1, 0.1, 0.1]. The final resource affinity matching value is 0.91 x (1-0.235) ≈ 0.696. At the same time, the system processes node B in the same way and finds that the resource affinity matching value of node B is 0.785, so node B will be given priority for scheduling of the task.

[0027] In specific embodiments, the node dependency relationship analysis based on the resource affinity matching value to obtain a resource dependency coefficient comprises: Performing association relationship mining on the computing nodes corresponding to the resource affinity matching value, constructing a node association graph, and assigning weights to the edges in the node association graph to obtain a weighted node association graph; Performing path traversal based on the weighted node association graph, extracting the shortest dependency paths between the computing nodes, and cumulatively calculating the weights of the shortest dependency paths to obtain a path dependency weight value; Performing normalization processing on the path dependency weight value to obtain a standardized path weight, and arranging the standardized path weight in a matrix form according to node pairs to obtain a dependency weight matrix; Performing row-by-row weighted average calculation based on the dependency weight matrix and the resource affinity matching value to obtain a resource dependency coefficient of each computing node.

[0028] Specifically, after completing the calculation of resource affinity matching values, the system takes these matching values as initial inputs to mine the association relationships between computing nodes and construct a node association graph. Each node in the graph represents a computing unit, and the edges in the graph represent the resource or task coordination relationships between nodes. For example, in a data center containing 10 computing nodes, if there is frequent data communication between node 1 and node 2, and node 3 and node 5 share storage resources, the system establishes edges between node 1 and node 2, and node 3 and node 5, indicating that there is a resource dependency relationship between them. Then, the system assigns weights to these edges, which can be set based on the communication delay, data transmission volume, historical task scheduling records, and other information between nodes. For example, the communication delay between node 1 and node 2 is 0.5 ms, the data transmission volume is 1.2 GB, and the historical coordination scheduling success rate is 90%, so the edge weight can be assigned as 0.85 by considering these factors, forming a weighted node association graph. On this basis, the system performs path traversal based on the weighted node association graph to extract the shortest dependency path between any two nodes. The shortest dependency path refers to the path with the smallest total weight of edges from one node to another, which is usually calculated using the Dijkstra algorithm or Floyd-Warshall algorithm. For example, there may be multiple paths between node 1 and node 6: path A passes through node 2 and node 4 with edge weights of 0.8 and 0.7, respectively, and path B passes through node 3 and node 5 with edge weights of 0.6 and 0.9, respectively. The system accumulates the weights of the two paths to calculate the path dependency weight values: 0.8 + 0.7 = 1.5 for path A and 0.6 + 0.9 = 1.5 for path B. If the two values are equal, the system may choose one of the paths as the shortest dependency path. In this way, the system can identify the optimal resource coordination path between any two nodes and record its path dependency weight value. Then, the system normalizes all path dependency weight values between node pairs to fall within the [0, 1] interval, forming standardized path weights. For example, assuming the minimum value of all path dependency weight values is 1.0 and the maximum value is 5.0, and the dependency weight value of a certain path is 2.5, then its normalized standardized path weight value is (2.5 - 1.0) / (5.0 - 1.0) = 0.375. The normalized weight values facilitate subsequent comparison and calculation, allowing the dependency relationships between different node pairs to have a unified measurement standard. Next, the system arranges these standardized path weights in a matrix according to the node pairs to construct a dependency weight matrix. For example, in a system consisting of 5 computing nodes, the dependency weight matrix will be a 5x5 matrix, where the value in the i-th row and j-th column represents the resource dependency degree of node i to node j.For example, if the normalized path weight of node 1 to node 2 is 0.375, the normalized path weight of node 1 to node 3 is 0.25, the normalized path weight of node 2 to node 4 is 0.45, and so on, a complete dependency weight matrix is finally formed for subsequent resource dependency coefficient calculation. Finally, the system performs a weighted average calculation on each row of the dependency weight matrix based on the resource affinity matching value to obtain the resource dependency coefficient of each computing node. Specifically, for each row in the dependency weight matrix, the system takes the corresponding resource affinity matching value as the weight and performs a weighted average calculation on each dependency weight value in the row to calculate the comprehensive influence value of the node in terms of resource dependency. For example, the resource affinity matching value of node 1 is 0.78, and the corresponding row vector in the dependency weight matrix is [0, 0.375, 0.25, 0.4, 0.15]. The weighted average result is: 0 x 0.78 + 0.375 x 0.78 + 0.25 x 0.78 + 0.4 x 0.78 + 0.15 x 0.78 = 0.78 x (0.375 + 0.25 + 0.4 + 0.15) = 0.78 x 1.175 = 0.9165. This value is the resource dependency coefficient of node 1, indicating its dependency importance in the resource coordination network. The higher the resource dependency coefficient, the stronger the resource coordination relationship between the node and other nodes, and the more the cooperation between the node and other nodes needs to be considered during scheduling. To further illustrate the practical application effect of this mechanism, assume that in a deep learning training platform, a user submits an image classification training task, and the system has calculated the resource affinity matching values of each node and constructed the dependency weight matrix. For example, the resource affinity matching value of node A is 0.82, and the corresponding row vector in the dependency weight matrix is [0, 0.4, 0.3, 0.25, 0.15]. The resource dependency coefficient of node A is 0.82 x (0.4 + 0.3 + 0.25 + 0.15) = 0.82 x 1.1 = 0.902. At the same time, the resource affinity matching value of node B is 0.75, and the dependency weight vector is [0.35, 0, 0.2, 0.15, 0.1]. The resource dependency coefficient of node B is 0.75 x (0.35 + 0.2 + 0.15 + 0.1) = 0.75 x 0.8 = 0.6. The system performs a weighted fusion of these resource dependency coefficients and resource affinity matching values to generate a comprehensive affinity value for subsequent node priority sorting and computing power mapping scheduling.

[0029] In specific embodiments, the path traversal based on the weighted node association graph and the extraction of the shortest dependency path between each computing node comprise: respectively, to obtain an initial path record table; An intermediate node is selected from the initial path record table in descending order of node degree, and path lengths of paths from the starting node to other nodes via the intermediate node are compared and updated to obtain an updated path record table; The path lengths in the updated path record table are subjected to minimum value screening to determine minimum path lengths of each node pair, and path node sequences corresponding to the minimum path lengths are extracted to obtain shortest dependency paths between the computing nodes.

[0030] Specifically, after the construction of the weighted node association graph is completed, each computing node in the system is considered as a vertex in the graph, and the resource collaboration relationship between nodes is connected by edges, each edge has a weight value, which represents the closeness of resource dependence between two nodes. For example, in a data center containing 5 computing nodes (A, B, C, D, E), there may be an edge between nodes A and B with a weight of 0.6, indicating that there is a certain resource collaboration demand between them; the edge weight between nodes B and C is 0.4, indicating that the collaboration between them is stronger, and so on. In order to extract the shortest dependence path between any two nodes, the system first initializes the path record of each node. Taking node A as an example, the system sets the path length from A to itself as 0 and initializes the path node sequence as [A], indicating that the path from A to A only contains A itself; for the path length from A to other nodes (such as B, C, D, E), the system sets it to infinity (∞) in the initial state, indicating that the effective path has not been found. This initialization process provides a starting point for subsequent path updating and optimization. Subsequently, the system selects intermediate nodes in order of node degree from high to low based on the initial path record table, as the bridge for path updating. Node degree refers to the number of connections between this node and other nodes, the higher the degree, the more critical the node is in the resource collaboration network. For example, in the above 5-node system, the degrees of nodes B and C are 3 and 3 respectively, which are higher than those of other nodes, so the system preferentially selects B and C as intermediate nodes for path updating. Taking node B as an example, the system checks whether it can reach other nodes through node B from the starting node A, and calculates the corresponding path length. For example, it is known that the current path length from A to B is 0.6, and the edge weight from B to C is 0.4, so the path length from A to C through B is 0.6 + 0.4 = 1.0. Since this value is less than the initial infinity, the system updates the path length from A to C to 1.0, and updates the path node sequence to [A, B, C]. Similarly, if the edge weight from B to D is 0.9, then the path length from A to D through B is 0.6 + 0.9 = 1.5, which is also recorded as the current optimal path from A to D. After completing the path updating of the intermediate node B, the system continues to select the next intermediate node C for similar operations. For example, the edge weight from C to E is 0.7, so the path length from A to E through C is 1.0 (current path length from A to C) + 0.7 = 1.7, therefore the system updates the path length from A to E to 1.7, and the path node sequence to [A, B, C, E]. In addition, the system also checks other possible paths, such as the path length from A to E through D is 1.5 (A to D) + 0.5 (D to E) = 2.0, which is greater than 1.7, so it is not updated. The system repeats the above process for all nodes as starting nodes in turn to ensure that the paths between each node pair are fully updated.Finally, the system filters the minimum path length in all path records and extracts the corresponding path node sequence to form a set of shortest dependency paths between computing nodes. For example, in the above example, the shortest dependency path from node A to E is [A, B, C, E] with a path length of 1.7, and the shortest dependency path from node D to E is [D, E] with a path length of 0.5. These shortest dependency paths not only reflect the resource collaboration relationship between nodes, but also provide an important basis for subsequent resource dependency coefficient calculation. For example, when building the dependency weight matrix later, these path lengths will be normalized to convert into standardized path weights, which are used to measure the dependency strength between different nodes. In this way, the system can more accurately evaluate the collaborative influence between nodes in the task scheduling process, thereby improving the intelligent level of resource scheduling and task execution efficiency. To further illustrate the practical application effect of this mechanism, assume that in a deep learning training platform, a user submits an image classification training task, and the system has built a weighted node association graph and extracted the shortest dependency paths through the above path traversal mechanism. For example, the path length between node A and node B is 0.6, the shortest path length from node A to node C is 1.0, and the path length from node C to node E is 0.7, so the shortest path length from node A to E is 1.7. These path lengths will be used for subsequent normalization and dependency weight matrix construction, thereby supporting the calculation of resource dependency coefficients and the determination of scheduling priorities. Through the above path traversal and shortest dependency path extraction mechanism, the system realizes the precise modeling of resource collaboration paths between computing nodes, providing key path dependency information for resource scheduling. This mechanism not only improves the intelligent level of task scheduling, but also provides data support for collaborative task execution between nodes. This shortest dependency path extraction method based on graph traversal, path updating, and minimum value filtering can effectively identify the optimal resource collaboration path between nodes, with significant technical advantages and engineering application value.

[0031] In specific embodiments, the power mapping scheduling of the task resource demand vector based on the node priority sequence obtains a power scheduling scheme, including: The node load state data is sorted according to the node priority sequence to obtain a sorted load state vector, and the sorted load state vector and the task resource demand vector are difference calculated to obtain a node resource gap value, and the node resource gap value is judged to be positive or negative to filter out candidate nodes with a non-positive resource gap value; The resource satisfaction degree is obtained based on the proportion calculation of the candidate node and the task resource demand vector; perform task fragmentation adaptation analysis on the candidate nodes whose resource satisfaction degrees reach the preset threshold, obtain a fragmentation adaptation scheme, and perform binding mapping on the fragmented tasks and the candidate nodes in the fragmentation adaptation scheme to obtain a preliminary scheduling mapping table; perform calculation on the node load balancing degrees in the preliminary scheduling mapping table to obtain a load balancing coefficient, and perform adjustment and optimization on the preliminary scheduling mapping table based on the load balancing coefficient to obtain a computing power scheduling scheme.

[0032] Specifically, after the generation of the node priority sequence is completed, the system sorts the node load state data of each computing node according to the priority sequence to form a sorted load state vector. For example, in a system composed of 5 computing nodes, assuming that the node priorities of nodes A, B, C, D, and E are 1, 3, 2, 5, and 4 in turn, the sorted node order will be A, C, B, E, and D, and the corresponding load state vectors are [A: GPU 18 TFLOPS, memory 28 GB, CPU 45%], [C: GPU 20 TFLOPS, memory 30 GB, CPU 50%], [B: GPU 19 TFLOPS, memory 25 GB, CPU 60%], [E: GPU 15 TFLOPS, memory 20 GB, CPU 70%], and [D: GPU 10 TFLOPS, memory 15 GB, CPU 85%], respectively. Subsequently, the system performs difference calculation on the sorted load state vector and the task resource requirement vector to obtain the node resource gap value of each node. For example, assuming that the task resource requirement vector is [GPU 20 TFLOPS, memory 32 GB, CPU 60%], the GPU resource gap of node A is 20 - 18 = 2 TFLOPS, the memory gap is 32 - 28 = 4 GB, and the CPU gap is 60% - 45% = 15%. The system judges the resource gap values to be positive or negative, and only retains the nodes with all resource gap values being non-positive as candidate nodes. For example, the GPU resource of node C is 20 TFLOPS (just meets the requirement), the memory is 30 GB (slightly lower than the requirement), and the CPU is 50% (lower than the task requirement), so its GPU resource gap is 0, the memory gap is 2 GB (negative), and the CPU gap is 10% (positive), and therefore the node will be screened as a candidate node because its resource gap values meet or approach the task requirement as a whole. Next, the system performs proportional calculation on the candidate node load state and the task resource requirement vector to obtain the resource satisfaction degree. The resource satisfaction degree is a quantitative evaluation index of whether the candidate node resources meet the task requirement, which is usually represented by the weighted average of the resource dimension matching degree. For example, the GPU dimension satisfaction degree of node C is 1.0 (just meets the requirement), the memory dimension satisfaction degree is 0.94 (30 / 32), and the CPU dimension satisfaction degree is 0.83 (50 / 60), and if the weights of each dimension are 0.5, 0.3, and 0.2, respectively, the resource satisfaction degree of node C is 0.5 x 1.0 + 0.3 x 0.94 + 0.2 x 0.83 ≈ 0.94, which is higher than the preset threshold 0.85, and therefore the node is confirmed as a valid candidate node. After confirming the candidate nodes, the system further performs task fragmentation adaptation analysis to determine whether the task can be reasonably split into multiple sub-tasks and mapped to different candidate nodes.For example, a deep learning training task can be split into multiple model training subtasks, each with different requirements for GPU resources, memory, and CPU. The system generates a fragmentation adaptation plan based on the granularity of task fragmentation, the availability of node resources, and the communication overhead between nodes, and binds each fragmented task to the corresponding candidate node to form a preliminary scheduling mapping table. For example, the task is split into three subtasks T1, T2, and T3, where T1 is mapped to node C, T2 is mapped to node B, and T3 is mapped to node A. Finally, the system calculates the node load balancing degree in the preliminary scheduling mapping table to assess whether the nodes will experience resource overload or uneven load after executing the task. The load balancing coefficient is an important indicator of the overall load distribution uniformity of the system, and is usually calculated based on the variance or standard deviation of node load changes. For example, if the load of node A increases from 45% to 65% after executing the task, the load of node B increases from 60% to 75%, and the load of node C increases from 50% to 60%, the system calculates the load balancing coefficient as 0.12 (the smaller the value, the more balanced the load). If the coefficient is higher than the preset threshold (e.g., 0.15), the system optimizes the preliminary scheduling mapping table, for example, by migrating some subtasks from node B to node E to alleviate the high load pressure on node B, thereby forming the final computing power scheduling plan. To further illustrate the practical application effect of this mechanism, assume that in a deep learning training platform, a user submits an image classification training task with a task resource requirement vector of [GPU 25 TFLOPS, memory 40GB, CPU 70%]. The system selects candidate nodes A, C, and B based on node priority and calculates their resource satisfaction degrees as 0.92, 0.95, and 0.88, respectively, all of which are higher than the threshold of 0.85. The system then splits the task into three subtasks and maps them to the three nodes, and through load balancing analysis, finds that the load of node B increases to 80% after executing the task, which is slightly higher than that of the other nodes. Therefore, the system migrates one of the subtasks from node B to node E, so that the load of each node is adjusted to A:65%, C:60%, B:68%, and E:55%, and the final load balancing coefficient is reduced to 0.09, and the overall load distribution of the system is more balanced. Through the above scheduling mapping and optimization mechanism, the system achieves efficient matching between task resource requirements and node resource states, not only improving task execution efficiency, but also enhancing the system's control ability over resource load distribution. This scheduling strategy based on node priority, resource gap judgment, resource satisfaction evaluation, task fragmentation adaptation, and load balancing optimization can effectively support task scheduling requirements in complex computing power environments, and has significant technical innovation and engineering application value.

[0033] The resource affinity computing power scheduling method in the embodiments of the present application is described above, and the resource affinity computing power scheduling device in the embodiments of the present application is described below. Please refer toFigure 2 An embodiment of the resource affinity computing power scheduling device in the embodiment of the application comprises: The acquisition module 21 is configured to acquire load states of each computing node in the target device by the computing power node monitoring module to obtain node load state data. The analysis module 23 is configured to perform node dependency relationship analysis based on the resource affinity matching value to obtain a resource dependency coefficient, and perform weighted calculation on the resource affinity matching value and the resource dependency coefficient to obtain a comprehensive affinity value. The analysis module 23 is configured to perform node dependency relationship analysis based on the resource affinity matching value to obtain a resource dependency coefficient, and perform weighted calculation on the resource affinity matching value and the resource dependency coefficient to obtain a comprehensive affinity value. The sorting module 24 is configured to sort the comprehensive affinity value in descending order to obtain a node priority sequence, and perform computing power mapping scheduling on the task resource demand vector based on the node priority sequence to obtain a computing power scheduling scheme.

[0034] In the embodiment, the specific implementation of each unit in the above device embodiment can refer to the description in the above method embodiment, and will not be described here.

[0035] Reference Figure 3 The embodiment of the application also provides a computer device, and an internal structure of the computer device can be as shown in Figure 3 The computer device comprises a processor, a memory, a display screen, an input device, a network interface and a database connected through a system bus. The processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device comprises a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program and a database. The internal memory provides an environment for the operating system and the computer program in the non-volatile storage medium. The database of the computer device is configured to store corresponding data in the embodiment. The network interface of the computer device is configured to communicate with an external terminal through a network connection. The computer program is executed by the processor to implement the above method.

[0036] Those skilled in the art can understand that Figure 3 The structure shown in the figure is only a block diagram of part of the structure related to the scheme of the application, and does not constitute a limitation on the computer device to which the scheme of the application is applied.

[0037] The embodiment of the present application further provides a computer readable storage medium, which stores a computer program, and the computer program is executed by a processor to realize the method.

[0038] Those skilled in the art can understand that all or part of the processes in the above-mentioned embodiment methods can be completed by a computer program instructing relevant nodes, and the computer program can be stored in a non-volatile computer readable storage medium. When the computer program is executed, the computer program can include the processes of the above-mentioned embodiment methods. Any reference to memory, storage, database or other medium provided by the present application and used in the embodiments can include non-volatile and / or volatile memory. The non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory. The volatile memory can include random access memory (RAM) or external cache memory. As an illustration but not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (SSRSDRAM), enhanced SDRAM (ESDRAM), synchronous link (Synchlink) DRAM (SLDRAM), memory bus (Rambus) direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM) and memory bus dynamic RAM, etc.

[0039] It should be noted that in this document, the terms "comprising", "including", or any other variant thereof are intended to cover non-exclusive inclusions, so that processes, devices, articles or methods including a series of elements not only include those elements, but also include other elements not explicitly listed, or include elements inherent to such processes, devices, articles or methods. Without more limitations, the element defined by the statement "including a" does not exclude the presence of another identical element in the process, device, article or method including the element.

[0040] The above description is only the preferred embodiment of the present application, and does not limit the patent scope of the present application. Any equivalent structure or equivalent process transformation, or direct or indirect application in other related technical fields, as described in the specification and drawings of the present application, are also included in the patent protection scope of the present application.

Claims

1. A resource affinity-based computing power scheduling method, characterized in that, Includes the following steps: The load status of each computing node in the target device is collected by the computing node monitoring module to obtain node load status data. The computational tasks submitted by the target user are parsed to obtain a task resource requirement vector. Based on the node load status data, the task resource requirement vector is matched for affinity to obtain a resource affinity matching value. Node dependency analysis is performed based on the resource affinity matching value to obtain the resource dependency coefficient. The resource affinity matching value and the resource dependency coefficient are then weighted and calculated to obtain the comprehensive affinity value. The comprehensive affinity values ​​are sorted in descending order to obtain a node priority sequence. Based on the node priority sequence, the task resource requirement vector is mapped and scheduled to obtain a computing power scheduling scheme.

2. The resource affinity-based computing power scheduling method according to claim 1, characterized in that, The process involves collecting load status data from each computing node in the target device via a computing node monitoring module, resulting in node load status data, including: The computing node monitoring module periodically samples each computing node in the target device to obtain raw load time series data, and performs outlier removal processing on the raw load time series data to obtain preprocessed load time series data. Based on the preprocessed load time series data, feature dimensions are extracted to obtain multi-dimensional load features, and the multi-dimensional load features are normalized to obtain standardized load features. Spatiotemporal correlation analysis is performed on the standardized load features to obtain the node load correlation matrix. The standardized load feature set and the node load correlation matrix are then fused to obtain node load status data.

3. The resource affinity-based computing power scheduling method according to claim 1, characterized in that, The process of parsing the computational tasks submitted by the target user to obtain a task resource requirement vector includes: The syntactic structure of the description text in the computing task submitted by the target user is parsed to extract the task attribute feature set, and the computing task is classified and encoded based on the task attribute feature set to obtain the task classification encoding vector. Based on the task classification encoding vector, a matching search is performed in the preset resource mapping rule base to obtain the task resource requirement vector.

4. The resource affinity-based computing power scheduling method according to claim 1, characterized in that, The step of performing affinity matching on the task resource demand vector based on the node load status data to obtain a resource affinity matching value includes: The node load status data is subjected to dimension extraction to obtain a node dimension vector, and the dimension of the task resource requirement vector is aligned with the node dimension vector to obtain a set of feature vectors of the same dimension. The node load status data is vectorized to obtain the node load status vector. Based on the same-dimensional feature vector group, the cosine similarity between the task resource demand vector and the node load status vector is calculated to obtain the basic matching coefficient. The absolute value of the difference between the corresponding dimensions in the same-dimensional feature vector group is calculated to obtain the set of dimension difference values. The set of dimensional difference values ​​is normalized to obtain a normalized set of difference values, and the normalized set of difference values ​​is weighted and summed with a preset dimensional weight to obtain a comprehensive difference coefficient. The resource affinity matching value is obtained by numerically fusing the basic matching coefficient and the comprehensive difference coefficient.

5. The resource affinity-based computing power scheduling method according to claim 1, characterized in that, The node dependency analysis based on the resource affinity matching value, to obtain the resource dependency coefficient, includes: The association relationships of the computing nodes corresponding to the resource affinity matching values ​​are mined to construct a node association graph. Weights are assigned to the edges in the node association graph to obtain a weighted node association graph. Based on the weighted node association graph, a path traversal is performed to extract the shortest dependency path between each computing node, and the weight of the shortest dependency path is accumulated to obtain the path dependency weight value. The path dependency weight values ​​are normalized to obtain standardized path weights, and the standardized path weights are arranged in a matrix according to node pairs to obtain a dependency weight matrix. The resource dependency coefficient of each computing node is obtained by performing a row-by-row weighted average calculation based on the dependency weight matrix and the resource affinity matching value.

6. The resource affinity-based computing power scheduling method according to claim 5, characterized in that, The step of traversing paths based on the weighted node association graph to extract the shortest dependency paths between computing nodes includes: For each computation node in the weighted node association graph, initialize the path record to obtain an initial path record table; In the initial path record table, intermediate nodes are selected in descending order of node degree. The path lengths from the starting node to other nodes via intermediate nodes are compared and updated to obtain the updated path record table. The path lengths in the updated path record table are filtered by minimum value to determine the minimum path length for each node pair, and the path node sequence corresponding to the minimum path length is extracted to obtain the shortest dependency path between each computing node.

7. The resource affinity-based computing power scheduling method according to claim 1, characterized in that, The step of performing computing power mapping and scheduling on the task resource demand vector based on the node priority sequence to obtain a computing power scheduling scheme includes: The node load status data is sorted according to the node priority sequence to obtain a sorted load status vector. The difference between the sorted load status vector and the task resource demand vector is calculated to obtain the node resource gap value. The node resource gap value is judged as positive or negative, and candidate nodes with non-positive resource gap values ​​are selected. The resource satisfaction level is obtained by calculating the ratio between the candidate nodes and the task resource requirement vector. For candidate nodes whose resource satisfaction reaches a preset threshold, a task sharding adaptation analysis is performed to obtain a sharding adaptation scheme. The sharding tasks in the sharding adaptation scheme are then bound and mapped to the candidate nodes to obtain a preliminary scheduling mapping table. The load balancing degree of the nodes in the preliminary scheduling mapping table is calculated to obtain the load balancing coefficient. Based on the load balancing coefficient, the preliminary scheduling mapping table is adjusted and optimized to obtain the computing power scheduling scheme.

8. A resource affinity-based computing power scheduling device, characterized in that, include: The data acquisition module is used to collect the load status of each computing node in the target device through the computing node monitoring module, and obtain node load status data. The parsing module is used to parse the computing tasks submitted by the target user to obtain the task resource requirement vector, and to perform affinity matching on the task resource requirement vector based on the node load status data to obtain the resource affinity matching value. The analysis module is used to perform node dependency analysis based on the resource affinity matching value, obtain the resource dependency coefficient, and perform a weighted calculation on the resource affinity matching value and the resource dependency coefficient to obtain a comprehensive affinity value. The sorting module is used to sort the comprehensive affinity values ​​in descending order to obtain a node priority sequence, and to perform computing power mapping and scheduling on the task resource requirement vector based on the node priority sequence to obtain a computing power scheduling scheme.

9. A computer device, comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the method according to any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 7.

Images